http-request-manager 18.13.23 → 18.13.25

package/fesm2022/http-request-manager.mjs

@@ -926,9 +926,13 @@ class QueryParamsTrackerService {
             return false;
         this.cleanupExpiredEntries();
         if (!normalized.hasQuery) {
-            this.ensurePathState(normalized.pathKey);
-            this.persistState();
-            return true;
+            const pathState = this.ensurePathState(normalized.pathKey);
+            const pathSeenBefore = !!pathState.baselineQuery;
+            if (!pathSeenBefore) {
+                pathState.baselineQuery = {};
+                this.persistState();
+            }
+            return !pathSeenBefore;
         }
         if (options.mode === 'exact') {
             return this.checkExact(normalized, options);
@@ -943,7 +947,7 @@ class QueryParamsTrackerService {
     }
     checkExact(normalized, options) {
         const pathState = this.ensurePathState(normalized.pathKey);
-        const filteredQuery = normalized.query;
+        const filteredQuery = this.filterQueryByWatchParams(normalized.query, options.watchParams);
         if (Object.keys(filteredQuery).length === 0) {
             return false;
         }
@@ -952,11 +956,20 @@ class QueryParamsTrackerService {
             this.persistState();
             return true;
         }
-        return this.stringifyQuery(pathState.baselineQuery) === this.stringifyQuery(filteredQuery);
+        return this.stringifyQuery(pathState.baselineQuery) !== this.stringifyQuery(filteredQuery);
     }
     checkVariation(normalized, options) {
         const pathState = this.ensurePathState(normalized.pathKey);
-        const filteredQuery = normalized.query;
+        if (Array.isArray(options.watchParams) && options.watchParams.length === 0) {
+            const pathSeenBefore = !!pathState.baselineQuery;
+            if (!pathSeenBefore) {
+                pathState.baselineQuery = {};
+                pathState.watchExpiresAt = this.buildExpiryEpoch(typeof options.watchExpiresAt !== 'undefined' ? options.watchExpiresAt : options.watchParamsExpire);
+                this.persistState();
+            }
+            return !pathSeenBefore;
+        }
+        const filteredQuery = this.filterQueryByWatchParams(normalized.query, options.watchParams);
         const keys = Object.keys(filteredQuery);
         if (keys.length === 0) {
             return false;
@@ -980,6 +993,21 @@ class QueryParamsTrackerService {
         }
         return accepted;
     }
+    filterQueryByWatchParams(query, watchParams) {
+        if (!Array.isArray(watchParams)) {
+            return query;
+        }
+        if (watchParams.length === 0) {
+            return {};
+        }
+        const normalizedWatchParams = watchParams.map((p) => this.normalizeParamKey(p));
+        return Object.keys(query).reduce((acc, key) => {
+            if (normalizedWatchParams.includes(key)) {
+                acc[key] = query[key];
+            }
+            return acc;
+        }, {});
+    }
     normalizeRequestOptions(requestOptions) {
         const params = Array.isArray(requestOptions) ? requestOptions : [];
         const pathSegments = [];
@@ -1117,7 +1145,7 @@ class QueryParamsTrackerService {
                 pathState.consumedValuesByKey = {};
                 pathState.watchExpiresAt = undefined;
             }
-            const hasBaseline = Boolean(pathState.baselineQuery && Object.keys(pathState.baselineQuery).length > 0);
+            const hasBaseline = pathState.baselineQuery !== undefined;
             const hasTrackedValues = Object.keys(pathState.consumedValuesByKey).some((key) => (pathState.consumedValuesByKey[key] || []).length > 0);
             if (!hasBaseline && !hasTrackedValues) {
                 delete this.state.paths[pathKey];
@@ -7011,7 +7039,6 @@ class HTTPManagerStateService extends ComponentStore {
                 databaseOptions: this.databaseOptions
             });
             if (this.hasDatabase && this.databaseOptions?.table) {
-                console.log('[DB STORAGE] Stage 1');
                 return this.dbManagerService.databaseExists().pipe(switchMap((dbExists) => {
                     if (!dbExists) {
                         const initObs = this.initDBStorageAsync();
@@ -7020,7 +7047,6 @@ class HTTPManagerStateService extends ComponentStore {
                             return fetchFromAPI();
                         }));
                     }
-                    console.log('[DB STORAGE] Stage 2');
                     return this.dbManagerService.hasDatabaseTable(this.databaseOptions.table).pipe(switchMap((tableExists) => {
                         if (!tableExists) {
                             const initObs = this.initDBStorageAsync();
@@ -7029,14 +7055,10 @@ class HTTPManagerStateService extends ComponentStore {
                                 return fetchFromAPI();
                             }));
                         }
-                        console.log('[DB STORAGE] Stage 3');
                         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({
@@ -7045,7 +7067,6 @@ class HTTPManagerStateService extends ComponentStore {
                                     });
                                 }));
                             }
-                            console.log('[DB STORAGE] Stage 4');
                             const expectedSchema = this.buildSchemaFromAdapter();
                             const expectedSchemaSignature = this.buildSchemaSignature(expectedSchema);
                             if (storedSchemaSignature && storedSchemaSignature !== expectedSchemaSignature) {
@@ -7053,11 +7074,6 @@ class HTTPManagerStateService extends ComponentStore {
                                 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));
-                            console.log('[DB CHECK] Request options check:', {
-                                shouldMakeRequest,
-                                effectiveParams,
-                                options
-                            });
                             if (shouldMakeRequest)
                                 return fetchFromAPI();
                             return this.dbManagerService.getTableRecords(this.databaseOptions.table).pipe(switchMap((dbData) => {
@@ -7065,15 +7081,8 @@ class HTTPManagerStateService extends ComponentStore {
                                     this.setData$(dbData);
                                     return of(dbData);
                                 }
-                                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 ? [] : {});
+                                // DB empty → fall back to API
+                                return fetchFromAPI();
                             }), catchError((error) => {
                                 const tableName = this.databaseOptions.table;
                                 console.warn('[DB STORAGE] getTableRecords failed, recreating table and falling back to API:', { table: tableName, error });
@@ -7231,13 +7240,8 @@ 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 })));
                     }
@@ -7248,16 +7252,8 @@ class HTTPManagerStateService extends ComponentStore {
                             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 });
+                            // DB empty → fall back to API
+                            return this.httpManagerService.getRequest(requestOptions, effectiveParams).pipe(map((apiData) => ({ data: apiData, fromCache: false })));
                         }));
                     }
                     this.setCachedRequestSignature(this.databaseOptions.table, 'STREAM', requestSignature);
@@ -7971,10 +7967,13 @@ class HTTPManagerStateService extends ComponentStore {
         return options;
     }
     buildQueryTrackerOptions(options) {
-        return {
-            watchParams: Array.isArray(options?.watchParams) ? options.watchParams : [],
+        const result = {
             watchExpiresAt: options?.watchExpiresAt,
         };
+        if (Array.isArray(options?.watchParams)) {
+            result.watchParams = options.watchParams;
+        }
+        return result;
     }
     normalizeObject(value) {
         if (Array.isArray(value)) {