http-request-manager 18.15.11 → 18.15.13

package/fesm2022/http-request-manager.mjs

@@ -1065,8 +1065,7 @@ function safeJsonParse(jsonStr, fallback) {
     try {
         return JSON.parse(jsonStr);
     }
-    catch (error) {
-        console.warn('Failed to parse JSON:', jsonStr.substring(0, 100));
+    catch {
         return fallback || null;
     }
 }
@@ -1078,8 +1077,7 @@ function safeJsonArrayParse(jsonStr, fallback = []) {
         const parsed = JSON.parse(jsonStr);
         return Array.isArray(parsed) ? parsed : fallback;
     }
-    catch (error) {
-        console.warn('Failed to parse JSON array:', jsonStr.substring(0, 100));
+    catch {
         return fallback;
     }
 }
@@ -6437,7 +6435,10 @@ class QueryParamsTrackerService {
     checkRequestOptions(requestOptions = [], options = {}) {
         this.ensureStateRestored();
         if (!this.ready$.value) {
-            return true;
+            // When tracker hasn't restored from localStorage yet, block the request
+            // so cached/state data is used instead of making a redundant API call.
+            // This prevents the first-call-after-refresh race condition.
+            return false;
         }
         const normalized = this.normalizeRequestOptions(requestOptions);
         if (!normalized.pathKey)
@@ -7273,99 +7274,7 @@ class HTTPManagerStateService extends ComponentStore {
                 table: this.databaseOptions?.table,
                 databaseOptions: this.databaseOptions
             });
-            if (this.hasDatabase && this.databaseOptions?.table) {
-                return this.dbManagerService.databaseExists().pipe(switchMap((dbExists) => {
-                    if (!dbExists) {
-                        const initObs = this.initDBStorageAsync();
-                        return initObs.pipe(switchMap(() => fetchFromAPI()), catchError((error) => {
-                            console.warn('[DB STORAGE] initDBStorageAsync failed when DB did not exist, continuing with API:', error);
-                            return fetchFromAPI();
-                        }));
-                    }
-                    return this.dbManagerService.hasDatabaseTable(this.databaseOptions.table).pipe(switchMap((tableExists) => {
-                        if (!tableExists) {
-                            const initObs = this.initDBStorageAsync();
-                            return initObs.pipe(switchMap(() => fetchFromAPI()), catchError((error) => {
-                                console.warn('[DB STORAGE] initDBStorageAsync failed when table missing, continuing with API:', error);
-                                return fetchFromAPI();
-                            }));
-                        }
-                        return this.localStorageManagerService.store$(this.databaseOptions.table).pipe(take(1), switchMap((storeData) => {
-                            console.log('[CacheDebug] storeData for table:', this.databaseOptions.table, { storeData, requestCache: storeData?.requestCache, expires: storeData?.expires });
-                            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()));
-                            }
-                            const expectedSchema = this.buildSchemaFromAdapter();
-                            const expectedSchemaSignature = this.buildSchemaSignature(expectedSchema);
-                            console.log('[CacheDebug] schema check:', { tableName: this.databaseOptions.table, storedSchemaSignature, expectedSchemaSignature, mismatch: storedSchemaSignature && storedSchemaSignature !== expectedSchemaSignature });
-                            if (storedSchemaSignature && storedSchemaSignature !== expectedSchemaSignature) {
-                                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 trackerAllowsRequest = this.checkTrackerAllowsRequest(this.databaseOptions.table, this.resolvePath(effectiveParams), options, storeData);
-                            if (trackerAllowsRequest) {
-                                const normalizedPath = this.trackerNormalizePath(this.resolvePath(effectiveParams));
-                                if (!normalizedPath.hasQuery) {
-                                    return this.dbManagerService.getTableRecords(this.databaseOptions.table).pipe(switchMap((dbData) => {
-                                        if (Array.isArray(dbData) && dbData.length > 0) {
-                                            this.setData$(dbData);
-                                            // Save cache metadata for both GET and STREAM request types so
-                                            // tracker/check logic can detect cached responses regardless
-                                            // of whether a subsequent call is a normal GET or a streaming GET.
-                                            const getSignature = requestSignature;
-                                            const streamRequestOptions = { ...(requestOptions || {}), stream: true };
-                                            const streamSignature = this.buildRequestSignature('STREAM', streamRequestOptions, effectiveParams);
-                                            this.saveRequestCacheMetadata(this.databaseOptions.table, 'GET', getSignature, storedSchemaSignature ?? expectedSchemaSignature ?? undefined, options);
-                                            this.saveRequestCacheMetadata(this.databaseOptions.table, 'STREAM', streamSignature, storedSchemaSignature ?? expectedSchemaSignature ?? undefined, options);
-                                            return of({ data: dbData, fromCache: true });
-                                        }
-                                        return fetchFromAPI();
-                                    }), catchError((error) => {
-                                        const tableName = this.databaseOptions.table;
-                                        console.warn('[DB STORAGE] fallback cache read failed, falling back to API:', { table: tableName, error });
-                                        return fetchFromAPI();
-                                    }));
-                                }
-                                return fetchFromAPI();
-                            }
-                            return this.dbManagerService.getTableRecords(this.databaseOptions.table).pipe(switchMap((dbData) => {
-                                if (Array.isArray(dbData) && dbData.length > 0) {
-                                    this.setData$(dbData);
-                                    this.saveRequestCacheMetadata(this.databaseOptions.table, 'GET', requestSignature, storedSchemaSignature ?? expectedSchemaSignature ?? undefined, options);
-                                    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 ? [] : {});
-                            }), catchError((error) => {
-                                const tableName = this.databaseOptions.table;
-                                console.warn('[DB STORAGE] getTableRecords failed, recreating table and falling back to API:', { table: tableName, error });
-                                const schema = this.buildSchemaFromAdapter();
-                                const tableDef = TableSchemaDef.adapt({ table: tableName, schema });
-                                return this.dbManagerService.createDatabaseTable(tableDef).pipe(switchMap(() => fetchFromAPI()), catchError((recreateError) => {
-                                    console.error('[DB STORAGE] Failed to recreate table after read error, continuing with API only:', recreateError);
-                                    return fetchFromAPI();
-                                }));
-                            }));
-                        }));
-                    }));
-                }));
-            }
-            return fetchFromAPI();
+            return this.resolveCacheDecision('GET', requestOptions, effectiveParams, options, fetchFromAPI);
         })));
         // FETCH RECORD
         this.fetchRecord = (options, method) => this.effect(() => of(RequestOptions.adapt(options)).pipe(tap(() => console.log('🔄 fetchRecord effect triggered with path:', options?.path, 'method:', method)), switchMap((options) => {
@@ -7505,62 +7414,29 @@ class HTTPManagerStateService extends ComponentStore {
             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 = () => {
-                    if (!this.tryBeginInFlightRequest(requestSignature)) {
-                        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 })), finalize(() => this.endInFlightRequest(requestSignature)));
-                };
-                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) {
-                        return fetchStreamFromAPI();
-                    }
-                    if (hasExpired) {
-                        return this.dbManagerService.clearTable(this.databaseOptions.table).pipe(switchMap(() => fetchStreamFromAPI()));
+            const requestSignature = this.buildRequestSignature('STREAM', requestOptions, effectiveParams);
+            const fetchStreamFromAPI = () => {
+                if (!this.tryBeginInFlightRequest(requestSignature)) {
+                    const currentStateData = this.get()?.data;
+                    if (Array.isArray(currentStateData) && currentStateData.length > 0) {
+                        return of({ data: currentStateData, fromCache: true });
                     }
-                    const storedSchemaSignature = this.getStoredSchemaSignature(storeData);
-                    const expectedSchema = this.buildSchemaFromAdapter();
-                    const expectedSchemaSignature = this.buildSchemaSignature(expectedSchema);
-                    if (storedSchemaSignature && storedSchemaSignature !== expectedSchemaSignature) {
-                        const tableDef = TableSchemaDef.adapt({ table: this.databaseOptions.table, schema: expectedSchema });
-                        return this.dbManagerService.clearTable(this.databaseOptions.table).pipe(switchMap(() => this.dbManagerService.createDatabaseTable(tableDef)), switchMap(() => fetchStreamFromAPI()));
+                    if (currentStateData &&
+                        !Array.isArray(currentStateData) &&
+                        Object.keys(currentStateData).length > 0) {
+                        return of({ data: currentStateData, fromCache: true });
                     }
-                    const trackerAllowsRequest = this.checkTrackerAllowsRequest(this.databaseOptions.table, this.resolvePath(effectiveParams), options, storeData);
-                    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 });
-                        }));
-                    }
-                    return fetchStreamFromAPI();
-                })).pipe(tap((packet) => {
+                    return of({ data: this.dataType === DataType.ARRAY ? [] : {}, fromCache: true });
+                }
+                if (this.hasDatabase && this.databaseOptions?.table) {
+                    this.setCachedRequestSignature(this.databaseOptions.table, 'STREAM', requestSignature);
+                }
+                return this.httpManagerService.getRequest(requestOptions, effectiveParams).pipe(map((apiData) => ({ data: apiData, fromCache: false })), finalize(() => this.endInFlightRequest(requestSignature)));
+            };
+            // Use shared gating decision for parity with GET
+            const cacheDecision$ = this.resolveCacheDecision('STREAM', requestOptions, effectiveParams, options, fetchStreamFromAPI);
+            if (this.hasDatabase && this.databaseOptions?.table) {
+                return cacheDecision$.pipe(tap((packet) => {
                     const res = packet?.data;
                     // console.log('[DEBUG] Streaming response received:', res)
                     if (res && res.length > 0) {
@@ -7827,6 +7703,129 @@ class HTTPManagerStateService extends ComponentStore {
         });
         return [...updatedData, ...addedData];
     }
+    // --------------------------------------------------------------------------------------------------
+    // SHARED CACHE GATING DECISION
+    // --------------------------------------------------------------------------------------------------
+    /**
+     * Resolves whether a request should use cached/DB data or call the API.
+     * Shared by both fetchRecords (GET) and fetchStream (STREAM) to ensure parity.
+     *
+     * Decision order:
+     * 1. forceRefresh → API
+     * 2. cache expired → clear + API
+     * 3. schema mismatch → clear + rebuild + API
+     * 4. tracker blocks request → DB/state fallback
+     * 5. tracker allows request → API (with optional no-query DB shortcut)
+     *
+     * Returns an observable of the result data.
+     */
+    resolveCacheDecision(requestType, requestOptions, effectiveParams, options, fetchFromAPI) {
+        if (!this.hasDatabase || !this.databaseOptions?.table) {
+            return fetchFromAPI();
+        }
+        const requestSignature = this.buildRequestSignature(requestType, requestOptions, effectiveParams);
+        return this.dbManagerService.databaseExists().pipe(switchMap((dbExists) => {
+            if (!dbExists) {
+                return this.initDBStorageAsync().pipe(switchMap(() => fetchFromAPI()), catchError((error) => {
+                    console.warn('[DB STORAGE] initDBStorageAsync failed when DB did not exist, continuing with API:', error);
+                    return fetchFromAPI();
+                }));
+            }
+            return this.dbManagerService.hasDatabaseTable(this.databaseOptions.table).pipe(switchMap((tableExists) => {
+                if (!tableExists) {
+                    return this.initDBStorageAsync().pipe(switchMap(() => fetchFromAPI()), catchError((error) => {
+                        console.warn('[DB STORAGE] initDBStorageAsync failed when table missing, continuing with API:', error);
+                        return fetchFromAPI();
+                    }));
+                }
+                return this.localStorageManagerService.store$(this.databaseOptions.table).pipe(take(1), switchMap((storeData) => {
+                    console.log('[CacheDebug] storeData for table:', this.databaseOptions.table, { storeData, requestCache: storeData?.requestCache, expires: storeData?.expires });
+                    // 1. forceRefresh → API
+                    const forceRefresh = !!options?.forceRefresh;
+                    if (forceRefresh) {
+                        return fetchFromAPI();
+                    }
+                    // 2. cache expired → clear + API
+                    const expires = storeData?.expires || 0;
+                    const hasExpired = expires > 0 && this.utils.hasExpired(expires);
+                    if (hasExpired) {
+                        return this.dbManagerService.clearTable(this.databaseOptions.table).pipe(switchMap(() => fetchFromAPI()));
+                    }
+                    // 3. schema mismatch → clear + rebuild + API
+                    const storedSchemaSignature = this.getStoredSchemaSignature(storeData);
+                    const expectedSchema = this.buildSchemaFromAdapter();
+                    const expectedSchemaSignature = this.buildSchemaSignature(expectedSchema);
+                    console.log('[CacheDebug] schema check:', { tableName: this.databaseOptions.table, storedSchemaSignature, expectedSchemaSignature, mismatch: storedSchemaSignature && storedSchemaSignature !== expectedSchemaSignature });
+                    if (storedSchemaSignature && storedSchemaSignature !== expectedSchemaSignature) {
+                        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()));
+                    }
+                    // 4 & 5. tracker decision
+                    const trackerAllowsRequest = this.checkTrackerAllowsRequest(this.databaseOptions.table, this.resolvePath(effectiveParams), options, storeData);
+                    if (trackerAllowsRequest) {
+                        // For no-query paths, try DB first before API
+                        const normalizedPath = this.trackerNormalizePath(this.resolvePath(effectiveParams));
+                        if (!normalizedPath.hasQuery) {
+                            return this.dbManagerService.getTableRecords(this.databaseOptions.table).pipe(switchMap((dbData) => {
+                                if (Array.isArray(dbData) && dbData.length > 0) {
+                                    this.setData$(dbData);
+                                    // Save cache metadata for both GET and STREAM request types so
+                                    // tracker/check logic can detect cached responses regardless
+                                    // of whether a subsequent call is a normal GET or a streaming GET.
+                                    const getSignature = this.buildRequestSignature('GET', requestOptions, effectiveParams);
+                                    const streamRequestOptions = { ...(requestOptions || {}), stream: true };
+                                    const streamSignature = this.buildRequestSignature('STREAM', streamRequestOptions, effectiveParams);
+                                    this.saveRequestCacheMetadata(this.databaseOptions.table, 'GET', getSignature, storedSchemaSignature ?? expectedSchemaSignature ?? undefined, options);
+                                    this.saveRequestCacheMetadata(this.databaseOptions.table, 'STREAM', streamSignature, storedSchemaSignature ?? expectedSchemaSignature ?? undefined, options);
+                                    return of({ data: dbData, fromCache: true });
+                                }
+                                return fetchFromAPI();
+                            }), catchError((error) => {
+                                const tableName = this.databaseOptions.table;
+                                console.warn('[DB STORAGE] fallback cache read failed, falling back to API:', { table: tableName, error });
+                                return fetchFromAPI();
+                            }));
+                        }
+                        return fetchFromAPI();
+                    }
+                    // tracker blocks request → DB/state fallback
+                    return this.dbManagerService.getTableRecords(this.databaseOptions.table).pipe(switchMap((dbData) => {
+                        if (Array.isArray(dbData) && dbData.length > 0) {
+                            this.setData$(dbData);
+                            // Save cache metadata for both GET and STREAM request types so
+                            // tracker/check logic can detect cached responses regardless
+                            // of whether a subsequent call is a normal GET or a streaming GET.
+                            const getSignature = this.buildRequestSignature('GET', requestOptions, effectiveParams);
+                            const streamRequestOptions = { ...(requestOptions || {}), stream: true };
+                            const streamSignature = this.buildRequestSignature('STREAM', streamRequestOptions, effectiveParams);
+                            this.saveRequestCacheMetadata(this.databaseOptions.table, 'GET', getSignature, storedSchemaSignature ?? expectedSchemaSignature ?? undefined, options);
+                            this.saveRequestCacheMetadata(this.databaseOptions.table, 'STREAM', streamSignature, storedSchemaSignature ?? expectedSchemaSignature ?? undefined, options);
+                            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 ? [] : {});
+                    }), catchError((error) => {
+                        const tableName = this.databaseOptions.table;
+                        console.warn('[DB STORAGE] getTableRecords failed, recreating table and falling back to API:', { table: tableName, error });
+                        const schema = this.buildSchemaFromAdapter();
+                        const tableDef = TableSchemaDef.adapt({ table: tableName, schema });
+                        return this.dbManagerService.createDatabaseTable(tableDef).pipe(switchMap(() => fetchFromAPI()), catchError((recreateError) => {
+                            console.error('[DB STORAGE] Failed to recreate table after read error, continuing with API only:', recreateError);
+                            return fetchFromAPI();
+                        }));
+                    }));
+                }));
+            }));
+        }));
+    }
     initDBStorageAsync() {
         console.log('[initDBStorageAsync] Starting initialization:', {
             dataType: this.dataType,
@@ -8498,7 +8497,7 @@ class HTTPManagerStateService extends ComponentStore {
         return Math.floor(Date.now() / 1000) + Number(parsed[1]) * seconds;
     }
     checkTrackerAllowsRequest(tableName, path, options, storeData) {
-        if (options && 'watchParams' in options) {
+        if (options && Array.isArray(options.watchParams)) {
             return this.queryParamsTrackerService.checkRequestOptions(path, {
                 watchParams: options.watchParams,
                 watchExpiresAt: options?.watchExpiresAt,