http-request-manager 18.13.25 → 18.13.27

package/fesm2022/http-request-manager.mjs

@@ -1165,20 +1165,20 @@ class QueryParamsTrackerService {
             return;
         }
         this.stateRestored = true;
-        this.initializeTrackingForSession();
+        // this.initializeTrackingForSession();
         this.restoreState();
     }
-    initializeTrackingForSession() {
-        if (!this.hasSessionStorage()) {
-            return;
-        }
-        const initialized = sessionStorage.getItem(TRACKER_SESSION_INIT_KEY);
-        if (initialized === '1') {
-            return;
-        }
-        this.clearTracking();
-        sessionStorage.setItem(TRACKER_SESSION_INIT_KEY, '1');
-    }
+    // private initializeTrackingForSession(): void {
+    //   if (!this.hasSessionStorage()) {
+    //     return;
+    //   }
+    //   const initialized = sessionStorage.getItem(TRACKER_SESSION_INIT_KEY);
+    //   if (initialized === '1') {
+    //     return;
+    //   }
+    //   this.clearTracking();
+    //   sessionStorage.setItem(TRACKER_SESSION_INIT_KEY, '1');
+    // }
     restoreState() {
         this.localStorageManager.store$(TRACKER_STORE_NAME)
             .pipe(take(1))
@@ -7056,9 +7056,13 @@ class HTTPManagerStateService extends ComponentStore {
                             }));
                         }
                         return this.localStorageManagerService.store$(this.databaseOptions.table).pipe(take(1), switchMap((storeData) => {
+                            const forceRefresh = !!options?.forceRefresh;
                             const storedSchemaSignature = this.getStoredSchemaSignature(storeData);
                             const expires = storeData?.expires || 0;
                             const hasExpired = expires > 0 && this.utils.hasExpired(expires);
+                            if (forceRefresh) {
+                                return fetchFromAPI();
+                            }
                             if (hasExpired) {
                                 return this.dbManagerService.clearTable(this.databaseOptions.table).pipe(switchMap(() => fetchFromAPI()), tap(() => {
                                     this.localStorageManagerService.updateStore({
@@ -7073,16 +7077,28 @@ class HTTPManagerStateService extends ComponentStore {
                                 const tableDef = TableSchemaDef.adapt({ table: this.databaseOptions.table, schema: expectedSchema });
                                 return this.dbManagerService.clearTable(this.databaseOptions.table).pipe(switchMap(() => this.dbManagerService.createDatabaseTable(tableDef)), switchMap(() => fetchFromAPI()));
                             }
-                            const shouldMakeRequest = this.queryParamsTrackerService.checkRequestOptions(this.resolvePath(effectiveParams), this.buildQueryTrackerOptions(options));
-                            if (shouldMakeRequest)
-                                return fetchFromAPI();
+                            const hasTrackerConfig = Array.isArray(options?.watchParams) && options.watchParams.length > 0;
+                            if (hasTrackerConfig) {
+                                const trackerAllowsRequest = this.queryParamsTrackerService.checkRequestOptions(this.resolvePath(effectiveParams), this.buildQueryTrackerOptions(options));
+                                if (trackerAllowsRequest) {
+                                    return fetchFromAPI();
+                                }
+                            }
                             return this.dbManagerService.getTableRecords(this.databaseOptions.table).pipe(switchMap((dbData) => {
                                 if (Array.isArray(dbData) && dbData.length > 0) {
                                     this.setData$(dbData);
                                     return of(dbData);
                                 }
-                                // DB empty → fall back to API
-                                return fetchFromAPI();
+                                const currentStateData = this.get()?.data;
+                                if (Array.isArray(currentStateData) && currentStateData.length > 0) {
+                                    return of(currentStateData);
+                                }
+                                if (currentStateData &&
+                                    !Array.isArray(currentStateData) &&
+                                    Object.keys(currentStateData).length > 0) {
+                                    return of(currentStateData);
+                                }
+                                return of(this.dataType === DataType.ARRAY ? [] : {});
                             }), catchError((error) => {
                                 const tableName = this.databaseOptions.table;
                                 console.warn('[DB STORAGE] getTableRecords failed, recreating table and falling back to API:', { table: tableName, error });
@@ -7240,21 +7256,36 @@ class HTTPManagerStateService extends ComponentStore {
             if (this.hasDatabase && this.databaseOptions?.table) {
                 const requestSignature = this.buildRequestSignature('STREAM', requestOptions, effectiveParams);
                 return this.localStorageManagerService.store$(this.databaseOptions.table).pipe(take(1), switchMap((storeData) => {
+                    const forceRefresh = !!options?.forceRefresh;
                     const expires = storeData?.expires || 0;
                     const hasExpired = expires > 0 && this.utils.hasExpired(expires);
+                    if (forceRefresh) {
+                        this.setCachedRequestSignature(this.databaseOptions.table, 'STREAM', requestSignature);
+                        return this.httpManagerService.getRequest(requestOptions, effectiveParams).pipe(map((apiData) => ({ data: apiData, fromCache: false })));
+                    }
                     if (hasExpired) {
                         return this.dbManagerService.clearTable(this.databaseOptions.table).pipe(tap(() => this.setCachedRequestSignature(this.databaseOptions.table, 'STREAM', requestSignature)), switchMap(() => this.httpManagerService.getRequest(requestOptions, effectiveParams)), map((apiData) => ({ data: apiData, fromCache: false })));
                     }
-                    const trackerAllowsRequest = this.queryParamsTrackerService.checkRequestOptions(this.resolvePath(effectiveParams), this.buildQueryTrackerOptions(options));
-                    const shouldMakeRequest = trackerAllowsRequest;
-                    if (!shouldMakeRequest) {
-                        return this.dbManagerService.getTableRecords(this.databaseOptions.table).pipe(switchMap((dbData) => {
-                            if (Array.isArray(dbData) && dbData.length > 0) {
-                                return of({ data: dbData, fromCache: true });
-                            }
-                            // DB empty → fall back to API
-                            return this.httpManagerService.getRequest(requestOptions, effectiveParams).pipe(map((apiData) => ({ data: apiData, fromCache: false })));
-                        }));
+                    const hasTrackerConfig = Array.isArray(options?.watchParams) && options.watchParams.length > 0;
+                    if (hasTrackerConfig) {
+                        const trackerAllowsRequest = this.queryParamsTrackerService.checkRequestOptions(this.resolvePath(effectiveParams), this.buildQueryTrackerOptions(options));
+                        if (!trackerAllowsRequest) {
+                            return this.dbManagerService.getTableRecords(this.databaseOptions.table).pipe(switchMap((dbData) => {
+                                if (Array.isArray(dbData) && dbData.length > 0) {
+                                    return of({ data: dbData, fromCache: true });
+                                }
+                                const currentStateData = this.get()?.data;
+                                if (Array.isArray(currentStateData) && currentStateData.length > 0) {
+                                    return of({ data: currentStateData, fromCache: true });
+                                }
+                                if (currentStateData &&
+                                    !Array.isArray(currentStateData) &&
+                                    Object.keys(currentStateData).length > 0) {
+                                    return of({ data: currentStateData, fromCache: true });
+                                }
+                                return of({ data: this.dataType === DataType.ARRAY ? [] : {}, fromCache: true });
+                            }));
+                        }
                     }
                     this.setCachedRequestSignature(this.databaseOptions.table, 'STREAM', requestSignature);
                     return this.httpManagerService.getRequest(requestOptions, effectiveParams).pipe(map((apiData) => ({ data: apiData, fromCache: false })));
@@ -7403,24 +7434,17 @@ class HTTPManagerStateService extends ComponentStore {
                 });
             }
         }
-        const wsOptions = this.apiOptions.ws;
-        if (!wsOptions) {
-            this.logger.debug('StateStore', 'WSOptions not provided; skipping WebSocket initialization');
-            return;
-        }
-        const wsId = String(wsOptions.id || '').trim();
-        if (wsId !== '') {
-            wsOptions.id = wsId;
+        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
-            wsOptions.id = this.prefixChannel(wsOptions.id, ChannelType.STATE);
-            this.logger.debug('StateStore', `🔒 Private state channel configured`, { channelId: wsOptions.id });
+            this.apiOptions.ws.id = this.prefixChannel(this.apiOptions.ws.id, ChannelType.STATE);
+            this.logger.debug('StateStore', `🔒 Private state channel configured`, { channelId: this.apiOptions.ws.id });
             // Store our own sessionId for filtering incoming messages
             this.ownSessionId = sessionStorage.getItem('WSID') || null;
             this.logger.debug('StateStore', `🆔 Stored own sessionId for message filtering`, { sessionId: this.ownSessionId });
             this.logger.debug('StateStore', `🔍 WebSocket configuration`, {
-                channelId: wsOptions.id,
-                wsServer: wsOptions.wsServer,
+                channelId: this.apiOptions.ws.id,
+                wsServer: this.apiOptions.ws.wsServer,
                 sessionId: this.ownSessionId,
                 path: this.apiOptions.path
             });
@@ -7432,15 +7456,13 @@ class HTTPManagerStateService extends ComponentStore {
                 // initWS is an effect that triggers when setApiRequestOptions is called with ws config
                 // The effect is already triggered by calling setApiRequestOptions above
             }
-            if (wsOptions.retry) {
-                this.maxRetries = wsOptions.retry.times || 3;
-                this.retryDelay = (wsOptions.retry.delay && wsOptions.retry.delay * 1000) || 5 * 1000;
+            if (this.apiOptions.ws?.retry) {
+                this.maxRetries = this.apiOptions.ws.retry.times || 3;
+                this.retryDelay = (this.apiOptions.ws.retry.delay && this.apiOptions.ws.retry.delay * 1000) || 5 * 1000;
                 this.wsNextRetry.next(this.retryDelay);
             }
             // Validate wsServer before attempting connection
-            const wsServer = String(wsOptions.wsServer || '').trim();
-            wsOptions.wsServer = wsServer;
-            if (!wsServer) {
+            if (!this.apiOptions.ws.wsServer || this.apiOptions.ws.wsServer === '') {
                 this.logger.error('StateStore', 'WSOptions invalid: wsServer is missing or empty');
                 return;
             }
@@ -7453,9 +7475,9 @@ class HTTPManagerStateService extends ComponentStore {
             this.connectionStatusSubscription = this.setupConnectionStatus().subscribe();
             // Make initial connection attempt
             this.logger.debug('StateStore', '🔄 Initial WebSocket connection attempt...');
-            this.httpManagerService.connect(wsOptions, wsOptions.jwtToken || '');
+            this.httpManagerService.connect(this.apiOptions.ws, this.apiOptions.ws.jwtToken || '');
             // Initialize WS effect to handle messages
-            this.initWS(wsOptions);
+            this.initWS(this.apiOptions.ws);
         }
         else {
             this.logger.warn('StateStore', 'WSOptions invalid Id: empty');
@@ -7967,13 +7989,10 @@ class HTTPManagerStateService extends ComponentStore {
         return options;
     }
     buildQueryTrackerOptions(options) {
-        const result = {
+        return {
+            watchParams: Array.isArray(options?.watchParams) ? options.watchParams : [],
             watchExpiresAt: options?.watchExpiresAt,
         };
-        if (Array.isArray(options?.watchParams)) {
-            result.watchParams = options.watchParams;
-        }
-        return result;
     }
     normalizeObject(value) {
         if (Array.isArray(value)) {