http-request-manager 18.15.9 → 18.15.11

package/fesm2022/http-request-manager.mjs

@@ -973,7 +973,7 @@ class StreamingProcessor {
                 return null;
             case HttpEventType.DownloadProgress:
                 if (event.partialText) {
-                    this.appendToBuffer(event.partialText);
+                    this.buffer = event.partialText;
                     const parsedData = this.parseBuffer();
                     // Only return NEW items since last parse (progressive updates)
                     const newItems = parsedData.slice(this.lastParsedLength);
@@ -995,7 +995,7 @@ class StreamingProcessor {
                 return null;
             case HttpEventType.Response:
                 if (event.body) {
-                    this.appendToBuffer(event.body);
+                    this.buffer = typeof event.body === 'string' ? event.body : this.buffer;
                     const parsedData = this.parseBuffer();
                     // Calculate final progress
                     const progress = {
@@ -1179,10 +1179,12 @@ function parseStreamData(buffer, contentType, config) {
  */
 function parseNdjson(buffer, config) {
     const results = [];
-    const lines = buffer.split('\n').filter(line => line.trim());
-    lines.forEach(line => {
+    const lines = buffer.split('\n');
+    // If the buffer doesn't end with \n, the last segment is an incomplete partial line — skip it
+    const completeLines = buffer.endsWith('\n') ? lines : lines.slice(0, -1);
+    completeLines.filter(line => line.trim()).forEach(line => {
         const trimmedLine = line.trim();
-        if (trimmedLine && trimmedLine.startsWith('{') && trimmedLine.endsWith('}')) {
+        if (trimmedLine && trimmedLine.startsWith('{')) {
             const parsed = safeJsonParse(trimmedLine);
             if (parsed)
                 results.push(parsed);
@@ -1906,6 +1908,7 @@ class WebSocketManagerService {
         }
         // Store jwt token for retry
         WebSocketManagerService.lastJwtToken = jwtToken;
+        WebSocketManagerService.lastOptions = options;
         WebSocketManagerService.jwtInvalidClose = false;
         // Mark as connecting
         WebSocketManagerService.isConnecting = true;
@@ -1925,7 +1928,6 @@ class WebSocketManagerService {
             WebSocketManagerService.connectionStatus.next(true);
             WebSocketManagerService.isConnecting = false;
             WebSocketManagerService.connectionInitialized = true;
-            WebSocketManagerService.lastOptions = options;
             // Emit reconnect event - MessageTrackerService will handle subscriptions with lastSeenId
             console.log(`🔄 Emitting reconnect event for MessageTrackerService`);
             WebSocketManagerService.onReconnect.next();
@@ -1957,7 +1959,7 @@ class WebSocketManagerService {
             WebSocketManagerService.subscribedChannels.next(new Set());
             console.log('✅ subscribedChannels cleared');
             if (WebSocketManagerService.jwtInvalidClose) {
-                console.error('🚫 WebSocket closed due to JWT_INVALID. Not retrying.');
+                console.error('🚫 WebSocket closed due to authentication block/invalid token. Not retrying.');
                 WebSocketManagerService.retryCount = 0;
                 return;
             }
@@ -2954,7 +2956,9 @@ class RequestService extends WebsocketService {
                 observe: 'events',
                 responseType: 'text',
                 reportProgress: true
-            }).pipe(tap(data => console.log('STREAM DATA', data)), requestStreaming({ streamType: options.streamType || StreamType.NDJSON }), this.requestStreaming(options), this.handleFinalize())
+            }).pipe(
+            // tap(data => console.log('STREAM DATA', data)),
+            requestStreaming({ streamType: options.streamType || StreamType.NDJSON }), this.requestStreaming(options), this.handleFinalize())
             : this.http.get(urlPath, headers).pipe(this.request(options));
     }
     createRecordRequest(options, data) {
@@ -7754,46 +7758,24 @@ class HTTPManagerStateService extends ComponentStore {
             else {
                 this.logger.debug('StateStore', '🔴 WebSocket connection is closed');
             }
-        }), switchMap(status => {
+        }), map(status => {
             if (status === true) {
                 this.shouldRetry = true;
                 this.wsRetryAttempts.next(0);
                 this.wsNextRetry.next(0);
-                return of(true);
-            }
-            if (!this.shouldRetry)
-                return of(false);
-            const countdownEnder$ = new Subject();
-            // Immediately reflect upcoming retry delay in seconds on UI
-            const seconds = this.retryDelay / 1000;
-            this.wsNextRetry.next(seconds);
-            return timer(0, this.retryDelay)
-                .pipe(take(this.maxRetries), tap(i => {
-                const attempt = i + 1;
-                this.wsRetryAttempts.next(attempt);
-                countdownEnder$.next();
-                // Validate WS options; abort retries if invalid
-                const hasValidWS = !!(this.apiOptions.ws && this.apiOptions.ws.wsServer && this.apiOptions.ws.wsServer !== '');
-                if (!hasValidWS) {
-                    this.shouldRetry = false;
-                    this.wsNextRetry.next(0);
-                    this.wsRetryAttempts.next(0);
-                    return; // Skip connect and countdown
-                }
-                console.log(`🔄 Retry attempt #${attempt}/${this.maxRetries}`);
-                this.httpManagerService.connect(this.apiOptions.ws, this.apiOptions.ws.jwtToken || '');
-                if (attempt === this.maxRetries) {
-                    this.wsNextRetry.next(0);
-                    //   console.error(`🚨 FAILED CONNECTION: Tried #${attempt} times`);
-                }
-                else {
-                    //   console.log(`⚠️ Retry Attempt #${attempt}: Retrying in ${this.retryDelay / 1000}s`);
-                    const seconds = this.retryDelay / 1000;
-                    timer(0, 1000).pipe(map(tick => seconds - tick), takeWhile(val => val >= 0), takeUntil(countdownEnder$)).subscribe(remaining => {
-                        this.wsNextRetry.next(remaining);
-                    });
-                }
-            }), map(() => false));
+                return true;
+            }
+            // Retry orchestration is centralized in WebSocketManagerService.connect/onclose
+            // and uses ws.retry from request options. Keep this stream as status/state only.
+            if (!this.shouldRetry) {
+                this.wsRetryAttempts.next(0);
+                this.wsNextRetry.next(0);
+                return false;
+            }
+            const nextAttempt = Math.min(this.wsRetryAttempts.value + 1, this.maxRetries);
+            this.wsRetryAttempts.next(nextAttempt);
+            this.wsNextRetry.next(nextAttempt >= this.maxRetries ? 0 : this.retryDelay / 1000);
+            return false;
         }));
     }
     appendMessages(message) {