http-request-manager 18.16.25 → 18.16.28

package/fesm2022/http-request-manager.mjs

@@ -6610,16 +6610,19 @@ class DatabaseManagerService extends DbService {
     }
     updateTableRecord(table, record) {
         const tableName = this.cleanTableName(table);
+        console.log(`🔵 updateTableRecord: INPUT table='${table}' CLEANED='${tableName}'`);
         return this.updateTableRecords(tableName, [record])
             .pipe(map(item => item.length > 0 ? item[0] : null));
     }
     updateTableRecords(table, records) {
         const tableName = this.cleanTableName(table);
+        console.log(`🔵 updateTableRecords: INPUT table='${table}' CLEANED='${tableName}' recordCount=${records.length}`);
         return this.getDatabaseTable(tableName).pipe(switchMap((tableData) => {
             if (!tableData) {
-                console.warn(`updateTableRecords: Table '${tableName}' not found`);
+                console.warn(`❌ updateTableRecords: Table '${tableName}' not found`);
                 return EMPTY;
             }
+            console.log(`✅ updateTableRecords: Table '${tableName}' FOUND, executing bulkPut with ${records.length} records`);
             const insertRecords = records.map((record) => {
                 const payload = { ...(record || {}) };
                 if (payload.id === undefined || payload.id === null || payload.id === '') {
@@ -7228,19 +7231,16 @@ class HTTPManagerStateService extends ComponentStore {
                 }
                 return this.httpManagerService.getRequest(requestOptions, effectiveParams).pipe(tap((data) => {
                     // Extract array from paginated response if needed
+                    // Data is already adapted by RequestService.request() pipe - no need to adapt again
                     const arrayData = (data?.results && Array.isArray(data.results)) ? data.results : data;
-                    // Apply adapter to response data
-                    let adaptedData = this.applyAdapter(arrayData);
-                    adaptedData = (!adaptedData) ? (this.dataType === DataType.ARRAY) ? [] : {} : adaptedData;
-                    this.setData$(adaptedData);
+                    this.setData$(arrayData);
                 }), concatMap((data) => {
                     // Extract array from paginated response for database storage
+                    // Data is already adapted by RequestService.request() pipe - no need to adapt again
                     const dbData = (data?.results && Array.isArray(data.results)) ? data.results : data;
-                    // Apply adapter before database storage
-                    const adaptedDbData = this.applyAdapter(dbData);
-                    if (this.hasDatabase && this.databaseOptions?.table && Array.isArray(adaptedDbData) && adaptedDbData.length > 0) {
+                    if (this.hasDatabase && this.databaseOptions?.table && Array.isArray(dbData) && dbData.length > 0) {
                         const tableName = this.databaseOptions.table;
-                        const schema = this.buildSchemaFromSample(adaptedDbData[0]);
+                        const schema = this.buildSchemaFromSample(dbData[0]);
                         const tableDef = TableSchemaDef.adapt({ table: tableName, schema });
                         const schemaSignature = this.buildSchemaSignature(schema);
                         // Always ensure table exists immediately before writing to avoid stale schema/store races.
@@ -7255,7 +7255,7 @@ class HTTPManagerStateService extends ComponentStore {
                                     console.warn('[DB STORAGE] Table create/open not ready, skipping DB write for this payload:', { table: tableName });
                                     return of(data);
                                 }
-                                return this.dbManagerService.createTableRecords(tableName, adaptedDbData).pipe(tap(() => this.saveRequestCacheMetadata(tableName, 'GET', requestSignature, schemaSignature, options)));
+                                return this.dbManagerService.createTableRecords(tableName, dbData).pipe(tap(() => this.saveRequestCacheMetadata(tableName, 'GET', requestSignature, schemaSignature, options)));
                             }));
                         }), catchError((error) => {
                             console.error('[DB STORAGE] Failed to ensure table and write records:', { table: tableName, schema, error });
@@ -7368,26 +7368,37 @@ class HTTPManagerStateService extends ComponentStore {
             return this.httpManagerService.getRequest(requestOptions, effectiveParams)
                 .pipe(tap((data) => {
                 console.log('📦 fetchRecord received data:', data);
-                // Apply adapter if provided
-                let adaptedData = this.applyAdapter(data);
-                adaptedData = (!adaptedData) ? (this.dataType === DataType.ARRAY) ? [] : {} : adaptedData;
+                // Data is already adapted by RequestService.request() pipe - no need to adapt again
+                const arrayData = (data?.results && Array.isArray(data.results)) ? data.results : data;
+                const finalData = (!arrayData) ? (this.dataType === DataType.ARRAY) ? [] : {} : arrayData;
                 const id = options.path?.length ? options.path[options.path.length - 1] : null;
+                // For single-record operations (CREATE, UPDATE, DELETE), extract from array if needed
+                let singleRecord = finalData;
+                if (Array.isArray(finalData) && finalData.length > 0) {
+                    singleRecord = finalData[0];
+                }
                 if (method === 'DELETE') {
                     console.log('🗑️ Deleting record with id:', id);
                     this.deleteData$({ id });
                 }
                 if (method === 'UPDATE') {
-                    console.log('✏️ Updating record:', adaptedData);
-                    this.updateData$(adaptedData);
+                    console.log('✏️ Updating record:', singleRecord);
+                    this.updateData$(singleRecord);
                 }
                 if (method === 'CREATE') {
-                    console.log('➕ Adding record:', adaptedData);
-                    this.addData$(adaptedData);
+                    console.log('➕ Adding record:', finalData);
+                    this.addData$(finalData);
                 }
             }), concatMap((data) => {
-                const adaptedData = this.applyAdapter(data);
+                // Data is already adapted by RequestService.request() pipe - no need to adapt again
+                const dbData = (data?.results && Array.isArray(data.results)) ? data.results : data;
                 const tableName = this.databaseOptions?.table;
                 const idFromPath = options.path?.length ? options.path[options.path.length - 1] : null;
+                // For single-record operations, extract from array if needed
+                let singleRecord = dbData;
+                if (Array.isArray(dbData) && dbData.length > 0) {
+                    singleRecord = dbData[0];
+                }
                 if (this.hasDatabase && tableName) {
                     switch (method) {
                         case 'DELETE':
@@ -7398,18 +7409,18 @@ class HTTPManagerStateService extends ComponentStore {
                             this.logger.warn('fetchRecord', 'DELETE method called but id is missing from path', { options });
                             break;
                         case 'UPDATE':
-                            if (adaptedData && adaptedData.id != null) {
-                                this.logger.debug('fetchRecord', 'Updating database record', { table: tableName, id: adaptedData.id, data: adaptedData });
-                                return this.dbManagerService.updateTableRecord(tableName, adaptedData);
+                            if (singleRecord && singleRecord.id != null) {
+                                this.logger.debug('fetchRecord', 'Updating database record', { table: tableName, id: singleRecord.id, data: singleRecord });
+                                return this.dbManagerService.updateTableRecord(tableName, singleRecord);
                             }
-                            this.logger.warn('fetchRecord', 'UPDATE method called but adaptedData or id is missing', { adaptedData, hasData: !!adaptedData, hasId: !!adaptedData?.id });
+                            this.logger.warn('fetchRecord', 'UPDATE method called but singleRecord or id is missing', { singleRecord, hasData: !!singleRecord, hasId: !!singleRecord?.id });
                             break;
                         case 'CREATE':
-                            if (adaptedData && adaptedData.id != null && adaptedData.id !== '') {
-                                this.logger.debug('fetchRecord', 'Creating database record', { table: tableName, id: adaptedData.id, data: adaptedData });
-                                return this.dbManagerService.createTableRecord(tableName, adaptedData);
+                            if (dbData && dbData.id != null && dbData.id !== '') {
+                                this.logger.debug('fetchRecord', 'Creating database record', { table: tableName, id: dbData.id, data: dbData });
+                                return this.dbManagerService.createTableRecord(tableName, dbData);
                             }
-                            this.logger.warn('fetchRecord', 'CREATE method called but data.id is invalid', { adaptedData });
+                            this.logger.warn('fetchRecord', 'CREATE method called but data.id is invalid', { dbData });
                             break;
                         default:
                             this.logger.debug('fetchRecord', 'Method does not require database operation', { method });
@@ -7421,7 +7432,7 @@ class HTTPManagerStateService extends ComponentStore {
                         hasTable: !!tableName
                     });
                 }
-                return of(adaptedData);
+                return of(dbData);
             }));
         })));
         // CREATE RECORD
@@ -7430,17 +7441,13 @@ class HTTPManagerStateService extends ComponentStore {
             const requestOptions = this.updateRequestOptions(options?.headers);
             const effectiveParams = this.getEffectiveParams(options?.path);
             return this.httpManagerService.postRequest(data, requestOptions, effectiveParams)
-                .pipe(tap((data) => {
-                // Apply adapter to response data
-                let adaptedData = this.applyAdapter(data);
-                adaptedData = (!adaptedData) ? (this.dataType === DataType.ARRAY) ? [] : {} : adaptedData;
-                this.addData$(adaptedData);
+                .pipe(tap((adaptedData) => {
+                // Data is already adapted by RequestService
+                const safeData = (!adaptedData) ? (this.dataType === DataType.ARRAY ? [] : {}) : adaptedData;
+                this.addData$(safeData);
                 this.operationSuccess.next(OperationResultModel.adapt({ success: true, operation: 'CREATE' }));
-                // Always call wsCommunication - it will queue if not connected
-                this.wsCommunication('CREATE', [...options?.path || [], adaptedData.id]);
-            }), concatMap((data) => {
-                // Apply adapter before database operations
-                const adaptedData = this.applyAdapter(data);
+                this.wsCommunication('CREATE', [...options?.path || [], safeData.id]);
+            }), concatMap((adaptedData) => {
                 if (this.hasDatabase && this.databaseOptions?.table && adaptedData?.id) {
                     return this.dbManagerService.createTableRecord(this.databaseOptions.table, adaptedData);
                 }
@@ -7453,17 +7460,13 @@ class HTTPManagerStateService extends ComponentStore {
             const requestOptions = this.updateRequestOptions(options?.headers);
             const effectiveParams = this.getEffectiveParams(options?.path);
             return this.httpManagerService.putRequest(data, requestOptions, effectiveParams)
-                .pipe(tap((data) => {
-                // Apply adapter to response data
-                let adaptedData = this.applyAdapter(data);
-                adaptedData = (!adaptedData) ? (this.dataType === DataType.ARRAY) ? [] : {} : adaptedData;
-                this.updateData$(adaptedData);
+                .pipe(tap((adaptedData) => {
+                // Data is already adapted by RequestService
+                const safeData = (!adaptedData) ? (this.dataType === DataType.ARRAY ? [] : {}) : adaptedData;
+                this.updateData$(safeData);
                 this.operationSuccess.next(OperationResultModel.adapt({ success: true, operation: 'UPDATE' }));
-                // Always call wsCommunication - it will queue if not connected
                 this.wsCommunication('UPDATE', [...options?.path || []]);
-            }), concatMap((data) => {
-                // Apply adapter before database operations
-                const adaptedData = this.applyAdapter(data);
+            }), concatMap((adaptedData) => {
                 if (this.hasDatabase && this.databaseOptions?.table && adaptedData?.id) {
                     return this.dbManagerService.updateTableRecord(this.databaseOptions.table, adaptedData);
                 }
@@ -7476,17 +7479,13 @@ class HTTPManagerStateService extends ComponentStore {
             const requestOptions = this.updateRequestOptions(options?.headers);
             const effectiveParams = this.getEffectiveParams(options?.path);
             return this.httpManagerService.deleteRequest(requestOptions, effectiveParams)
-                .pipe(tap((data) => {
-                // Apply adapter to response data
-                let adaptedData = this.applyAdapter(data);
-                adaptedData = (!adaptedData) ? (this.dataType === DataType.ARRAY) ? [] : {} : adaptedData;
-                this.deleteData$(adaptedData);
+                .pipe(tap((adaptedData) => {
+                // Data is already adapted by RequestService
+                const safeData = (!adaptedData) ? (this.dataType === DataType.ARRAY ? [] : {}) : adaptedData;
+                this.deleteData$(safeData);
                 this.operationSuccess.next(OperationResultModel.adapt({ success: true, operation: 'DELETE' }));
-                // Always call wsCommunication - it will queue if not connected
                 this.wsCommunication('DELETE', [...options?.path || []]);
-            }), concatMap((data) => {
-                // Apply adapter before database operations
-                const adaptedData = this.applyAdapter(data);
+            }), concatMap((adaptedData) => {
                 if (this.hasDatabase && this.databaseOptions?.table && adaptedData?.id) {
                     return this.dbManagerService.deleteTableRecord(this.databaseOptions.table, adaptedData.id);
                 }
@@ -7499,13 +7498,12 @@ class HTTPManagerStateService extends ComponentStore {
             const requestOptions = this.updateRequestOptions(options?.headers);
             const effectiveParams = this.getEffectiveParams(options?.path);
             return this.httpManagerService.postRequest(data, requestOptions, effectiveParams)
-                .pipe(tap((res) => {
-                // Apply adapter to streaming response
-                const adaptedRes = this.applyAdapter(res);
+                .pipe(tap((adaptedRes) => {
+                // Data is already adapted by RequestService
                 if (adaptedRes.length > 0)
                     this.setData$(adaptedRes);
                 this.streamedResponse = adaptedRes;
-            }), concatMap((res) => this.persistStreamDataToDb(res, options)), scan((acc, res) => {
+            }), concatMap((adaptedRes) => this.persistStreamDataToDb(adaptedRes, options)), scan((acc, res) => {
                 const previous = acc.current;
                 const current = res;
                 return { previous, current };
@@ -7520,14 +7518,12 @@ class HTTPManagerStateService extends ComponentStore {
             }));
         })));
         this.fetchStream = (options) => this.effect(() => of(options).pipe(tap(() => {
-            // console.log('[DEBUG] fetchStream called')
             this.streamedResponse = [];
             this.httpManagerService.isPending.next(true);
         }), switchMap((options) => {
             const requestOptions = this.updateRequestOptions(options?.headers);
             requestOptions.stream = true;
             const effectiveParams = this.getEffectiveParams(options?.path);
-            // console.log('[DEBUG] Making streaming request:', requestOptions)
             if (this.hasDatabase && this.databaseOptions?.table) {
                 const requestSignature = this.buildRequestSignature('STREAM', requestOptions, effectiveParams);
                 const fetchStreamFromAPI = () => {
@@ -7536,9 +7532,7 @@ class HTTPManagerStateService extends ComponentStore {
                         if (Array.isArray(currentStateData) && currentStateData.length > 0) {
                             return of({ data: currentStateData, fromCache: true });
                         }
-                        if (currentStateData &&
-                            !Array.isArray(currentStateData) &&
-                            Object.keys(currentStateData).length > 0) {
+                        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 });
@@ -7573,9 +7567,7 @@ class HTTPManagerStateService extends ComponentStore {
                                 if (Array.isArray(currentStateData) && currentStateData.length > 0) {
                                     return of({ data: currentStateData, fromCache: true });
                                 }
-                                if (currentStateData &&
-                                    !Array.isArray(currentStateData) &&
-                                    Object.keys(currentStateData).length > 0) {
+                                if (currentStateData && !Array.isArray(currentStateData) && Object.keys(currentStateData).length > 0) {
                                     return of({ data: currentStateData, fromCache: true });
                                 }
                                 return fetchStreamFromAPI();
@@ -7585,23 +7577,17 @@ class HTTPManagerStateService extends ComponentStore {
                     }));
                 })).pipe(tap((packet) => {
                     const res = packet?.data;
-                    // Apply adapter to streaming response
-                    const adaptedRes = this.applyAdapter(res);
-                    // console.log('[DEBUG] Streaming response received:', adaptedRes)
-                    if (adaptedRes && adaptedRes.length > 0) {
-                        // console.log('[DEBUG] Updating state with streaming data:', adaptedRes)
-                        this.setData$(adaptedRes);
-                        this.streamedResponse = [...this.streamedResponse, ...adaptedRes];
+                    // Data is already adapted by RequestService
+                    if (res && res.length > 0) {
+                        this.setData$(res);
+                        this.streamedResponse = [...this.streamedResponse, ...res];
                     }
                 }), concatMap((packet) => {
                     if (packet?.fromCache) {
                         return of(packet?.data);
                     }
                     return this.persistStreamDataToDb(packet?.data, options);
-                }), map((res) => {
-                    // console.log('[DEBUG] Returning data to subscribers:', res)
-                    return res;
-                }), catchError((error) => {
+                }), map((res) => res), catchError((error) => {
                     console.error('[DEBUG] Streaming error:', error);
                     return of([]);
                 }), finalize(() => this.httpManagerService.isPending.next(false)));
@@ -7609,23 +7595,12 @@ class HTTPManagerStateService extends ComponentStore {
             // If no database is configured, always call the API (do not check tracker)
             return this.httpManagerService.getRequest(requestOptions, effectiveParams)
                 .pipe(tap((res) => {
-                // Apply adapter to streaming response
-                const adaptedRes = this.applyAdapter(res);
-                console.log('[DEBUG] Streaming response received:', adaptedRes);
-                // Always update state with streaming data
-                if (adaptedRes && adaptedRes.length > 0) {
-                    // console.log('[DEBUG] Updating state with streaming data:', adaptedRes)
-                    this.setData$(adaptedRes);
-                    this.streamedResponse = [...this.streamedResponse, ...adaptedRes];
-                }
-                else {
-                    // console.log('[DEBUG] No streaming data or empty array:', adaptedRes)
+                // Data is already adapted by RequestService
+                if (res && res.length > 0) {
+                    this.setData$(res);
+                    this.streamedResponse = [...this.streamedResponse, ...res];
                 }
-            }), concatMap((res) => this.persistStreamDataToDb(res, options)), map((res) => {
-                // console.log('[DEBUG] Returning data to subscribers:', res)
-                return res; // Return the data so subscribers can receive it
-            }), catchError((error) => {
-                // console.error('[DEBUG] Streaming error:', error)
+            }), concatMap((res) => this.persistStreamDataToDb(res, options)), map((res) => res), catchError((error) => {
                 return of([]);
             }), finalize(() => this.httpManagerService.isPending.next(false)));
         })));
@@ -7913,17 +7888,16 @@ class HTTPManagerStateService extends ComponentStore {
         if (!this.hasDatabase || !this.databaseOptions?.table) {
             return of(payload);
         }
-        // Apply adapter to payload before processing
-        const adaptedPayload = this.applyAdapter(payload);
-        const dbData = (adaptedPayload?.results && Array.isArray(adaptedPayload.results))
-            ? adaptedPayload.results
-            : Array.isArray(adaptedPayload)
-                ? adaptedPayload
-                : adaptedPayload
-                    ? [adaptedPayload]
+        // Payload is already adapted by RequestService.requestStreaming() pipe - no need to adapt again
+        const dbData = (payload?.results && Array.isArray(payload.results))
+            ? payload.results
+            : Array.isArray(payload)
+                ? payload
+                : payload
+                    ? [payload]
                     : [];
         if (dbData.length === 0) {
-            return of(adaptedPayload);
+            return of(payload);
         }
         const tableName = this.databaseOptions.table;
         const requestOptions = this.updateRequestOptions(streamOptions?.headers);
@@ -7942,13 +7916,13 @@ class HTTPManagerStateService extends ComponentStore {
             return ensureTable$.pipe(switchMap((created) => {
                 if (!created) {
                     console.warn('[DB STORAGE] Stream table create/open not ready, skipping DB write for this chunk:', { table: tableName });
-                    return of(adaptedPayload);
+                    return of(payload);
                 }
-                return this.dbManagerService.createTableRecords(tableName, dbData).pipe(tap(() => this.saveRequestCacheMetadata(tableName, 'STREAM', requestSignature, schemaSignature, streamOptions)), map(() => adaptedPayload));
+                return this.dbManagerService.createTableRecords(tableName, dbData).pipe(tap(() => this.saveRequestCacheMetadata(tableName, 'STREAM', requestSignature, schemaSignature, streamOptions)), map(() => payload));
             }));
-        }), map(() => adaptedPayload), catchError((error) => {
+        }), map(() => payload), catchError((error) => {
             console.error('[DB STORAGE] Failed to persist streaming payload:', { table: tableName, schema, error });
-            return of(adaptedPayload);
+            return of(payload);
         }));
     }
     // WEBSOCKET COMMUNICATION (STATE MANAGER)
@@ -8270,19 +8244,8 @@ class HTTPManagerStateService extends ComponentStore {
         return Object.keys(obj).length === 0;
     }
     /**
-     * Apply adapter to data if adapter is provided
-     * Handles both array and single object responses
-     * Only applies adapter when it exists - returns data as-is otherwise
+     * Update request options with provided headers
      */
-    applyAdapter(data) {
-        if (!data || !this.apiOptions?.adapter) {
-            return data;
-        }
-        if (Array.isArray(data)) {
-            return data.map((item) => this.apiOptions.adapter(item));
-        }
-        return this.apiOptions.adapter(data);
-    }
     updateRequestOptions(headers) {
         const options = ApiRequest.adapt({ ...this.apiOptions });
         options.headers = (headers)
@@ -8406,6 +8369,58 @@ class HTTPManagerStateService extends ComponentStore {
             const currentQueryParams = { ...(currentEntry.queryParams || {}) };
             const currentQueryCombinations = [...(currentEntry.queryCombinations || [])];
             const currentQueryParamsExpires = currentEntry.queryParamsExpires ?? null;
+            // Extract query params from options?.path and build combination string
+            const resolvedPath = this.resolvePath(options?.path);
+            const extractedParams = {};
+            const ignoreQueryParams = Array.isArray(options?.ignoreQueryParams) ? options.ignoreQueryParams : [];
+            if (Array.isArray(resolvedPath)) {
+                const normalizedIgnore = ignoreQueryParams.map(p => this.trackerNormalizeParamKey(p));
+                resolvedPath.forEach((pathPart) => {
+                    // Extract query params from objects in the path array
+                    if (pathPart && typeof pathPart === 'object' && !Array.isArray(pathPart)) {
+                        Object.keys(pathPart).forEach((key) => {
+                            const normalizedKey = this.trackerNormalizeParamKey(key);
+                            const value = String(pathPart[key]);
+                            // Only add to queryParams if NOT in ignoreQueryParams
+                            if (!normalizedIgnore.includes(normalizedKey)) {
+                                if (!currentQueryParams[key]) {
+                                    currentQueryParams[key] = [];
+                                }
+                                if (!currentQueryParams[key].includes(value)) {
+                                    currentQueryParams[key].push(value);
+                                }
+                                // Track extracted param for combination string
+                                extractedParams[normalizedKey] = value;
+                            }
+                        });
+                    }
+                    else if (typeof pathPart === 'string') {
+                        // Parse URL query strings like 'items?active=true&location=6'
+                        const normalized = this.trackerNormalizePath([pathPart]);
+                        if (normalized.hasQuery) {
+                            const filtered = this.trackerFilterQuery(normalized.query, ignoreQueryParams);
+                            Object.assign(extractedParams, filtered);
+                            // Add filtered params to queryParams
+                            Object.keys(filtered).forEach((key) => {
+                                if (!currentQueryParams[key]) {
+                                    currentQueryParams[key] = [];
+                                }
+                                if (!currentQueryParams[key].includes(filtered[key])) {
+                                    currentQueryParams[key].push(filtered[key]);
+                                }
+                            });
+                        }
+                    }
+                });
+            }
+            // Build combination string if we have extracted params
+            if (Object.keys(extractedParams).length > 0) {
+                const keys = Object.keys(extractedParams).sort();
+                const combinationString = keys.map((k) => `${k}=${extractedParams[k]}`).join('&');
+                if (!currentQueryCombinations.includes(combinationString)) {
+                    currentQueryCombinations.push(combinationString);
+                }
+            }
             this.localStorageManagerService.updateStore({
                 name: tableName,
                 data: {
@@ -8416,7 +8431,7 @@ class HTTPManagerStateService extends ComponentStore {
                             ...currentEntry,
                             signature,
                             savedAt: Date.now(),
-                            path: this.resolvePath(options?.path),
+                            path: resolvedPath,
                             headers: this.filterHeaders(options?.headers),
                             queryCombinations: currentQueryCombinations,
                             queryParams: currentQueryParams,
@@ -8543,22 +8558,6 @@ class HTTPManagerStateService extends ComponentStore {
         });
         return result;
     }
-    trackerBuildExpiryEpoch(expireIn) {
-        if (typeof expireIn === 'undefined' || expireIn === null || expireIn === '')
-            return null;
-        if (typeof expireIn === 'number' && Number.isFinite(expireIn) && expireIn > 0) {
-            return Math.floor(Date.now() / 1000) + Math.floor(expireIn);
-        }
-        const raw = String(expireIn).trim().toLowerCase().replace(/\s+/g, '');
-        const parsed = raw.match(/^(\d+)(y|w|d|hr|h|mn|min|m|s)$/);
-        if (!parsed)
-            return null;
-        const toSeconds = { y: 31556926, w: 604800, d: 86400, hr: 3600, h: 3600, mn: 60, min: 60, m: 60, s: 1 };
-        const seconds = toSeconds[parsed[2]];
-        if (!seconds)
-            return null;
-        return Math.floor(Date.now() / 1000) + Number(parsed[1]) * seconds;
-    }
     checkTrackerAllowsRequest(tableName, type, path, options, storeData) {
         const normalized = this.trackerNormalizePath(path);
         const ignoreQueryParams = Array.isArray(options?.ignoreQueryParams) ? options.ignoreQueryParams : [];
@@ -8577,58 +8576,47 @@ class HTTPManagerStateService extends ComponentStore {
         const combinationString = keys.sort().map((k) => `${k}=${filtered[k]}`).join('&');
         // Legacy per-key queryParams for backward compatibility (read-only)
         const queryParams = { ...(meta.queryParams || {}) };
-        let queryParamsExpires = meta.queryParamsExpires ?? null;
+        const queryParamsExpires = meta.queryParamsExpires ?? null;
         // New combination-based tracking
-        let queryCombinations = [...(meta.queryCombinations || [])];
+        const queryCombinations = [...(meta.queryCombinations || [])];
         // Reset combinations if the request path has changed (different endpoint)
         // Use trackerNormalizePath so inline query strings (e.g. 'items?a=1') are stripped
         // before comparing, matching the same normalization applied to the current request.
         const storedPathKey = meta.path
             ? this.trackerNormalizePath(meta.path.filter((p) => typeof p === 'string' || typeof p === 'number').map(String)).pathKey
             : null;
-        if (storedPathKey && storedPathKey !== normalized.pathKey) {
-            queryCombinations = [];
-            // Also clear legacy per-key tracking so old data from a different path doesn't block
-            Object.keys(queryParams).forEach((k) => delete queryParams[k]);
-            queryParamsExpires = null;
-        }
-        if (queryParamsExpires !== null && queryParamsExpires <= now) {
-            queryCombinations = [];
-            queryParamsExpires = null;
-            Object.keys(queryParams).forEach((k) => delete queryParams[k]);
-        }
+        const pathChanged = storedPathKey && storedPathKey !== normalized.pathKey;
+        const isExpired = queryParamsExpires !== null && queryParamsExpires <= now;
+        const shouldReset = pathChanged || isExpired;
         // Determine if request is accepted (not yet tracked)
         // Use combination-based tracking when available; fall back to legacy per-key tracking
-        let accepted;
-        if (queryCombinations.length > 0) {
-            accepted = !queryCombinations.includes(combinationString);
-        }
-        else if (Object.keys(queryParams).length > 0) {
-            // Legacy per-key backward compatibility
-            accepted = !keys.every((key) => {
-                const consumed = queryParams[key] || [];
-                return consumed.includes(filtered[key]);
-            });
-        }
-        else {
-            accepted = true;
-        }
-        if (accepted) {
-            queryCombinations = [...queryCombinations, combinationString];
-            // Also update legacy queryParams so existing consumers still work
-            keys.forEach(key => {
+        const accepted = shouldReset
+            ? true
+            : queryCombinations.length > 0
+                ? !queryCombinations.includes(combinationString)
+                : Object.keys(queryParams).length > 0
+                    ? !keys.every((key) => (queryParams[key] || []).includes(filtered[key]))
+                    : true;
+        // Compute updated values immutably
+        const updatedQueryCombinations = accepted
+            ? [...queryCombinations, combinationString]
+            : queryCombinations;
+        const updatedQueryParams = accepted
+            ? keys.reduce((acc, key) => {
                 const value = filtered[key];
-                const consumed = queryParams[key] || [];
+                const consumed = acc[key] || [];
                 if (!consumed.includes(value)) {
-                    queryParams[key] = [...consumed, value];
+                    acc[key] = [...consumed, value];
                 }
-            });
-        }
-        const newExpiry = this.trackerBuildExpiryEpoch(options?.queryParamsExpiresIn);
-        if (newExpiry !== null) {
-            queryParamsExpires = newExpiry;
-        }
-        if (accepted || newExpiry !== null) {
+                return acc;
+            }, { ...queryParams })
+            : { ...queryParams };
+        const updatedQueryParamsExpires = this.utils.expires(options?.queryParamsExpiresIn) ?? queryParamsExpires;
+        // Apply reset if path changed or expired
+        const finalQueryCombinations = shouldReset ? updatedQueryCombinations : queryCombinations;
+        const finalQueryParams = shouldReset ? updatedQueryParams : queryParams;
+        const finalQueryParamsExpires = shouldReset ? updatedQueryParamsExpires : updatedQueryParamsExpires;
+        if (accepted || updatedQueryParamsExpires !== queryParamsExpires) {
             this.localStorageManagerService.store$(tableName).pipe(take(1), tap((latestStoreData) => {
                 const currentCache = latestStoreData?.requestCache || {};
                 const currentEntry = currentCache[type] || {};
@@ -8640,9 +8628,9 @@ class HTTPManagerStateService extends ComponentStore {
                             ...currentCache,
                             [type]: {
                                 ...currentEntry,
-                                queryCombinations,
-                                queryParams,
-                                queryParamsExpires,
+                                queryCombinations: finalQueryCombinations,
+                                queryParams: finalQueryParams,
+                                queryParamsExpires: finalQueryParamsExpires,
                             }
                         }
                     }