http-request-manager 18.13.22 → 18.13.24

package/fesm2022/http-request-manager.mjs

@@ -943,7 +943,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;
         }
@@ -956,7 +956,16 @@ class QueryParamsTrackerService {
     }
     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 +989,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 +1141,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];
@@ -6393,11 +6417,11 @@ class DatabaseManagerService extends DbService {
                 console.error(`createTableRecords: DB not open. Cannot write to '${tableName}'.`);
                 return EMPTY;
             }
-            if (!this.tables.some(t => t.name === tableName)) {
+            const tableInstance = this.tables.find(t => t.name === tableName);
+            if (!tableInstance) {
                 console.error(`createTableRecords: Table '${tableName}' does not exist in DB version ${this.verno}. Available:`, this.tables.map(t => t.name));
                 return EMPTY;
             }
-            const tableInstance = this.table(tableName);
             console.log(`createTableRecords: Bulk putting ${insertRecords.length} records into ${tableName}`);
             return from(tableInstance.bulkPut(insertRecords)).pipe(map(() => insertRecords));
         }));
@@ -7011,7 +7035,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 +7043,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,7 +7051,6 @@ 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);
@@ -7045,7 +7066,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 +7073,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) => {
@@ -7971,10 +7986,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)) {