http-request-manager 18.15.12 → 18.15.14

package/fesm2022/http-request-manager.mjs

@@ -6434,28 +6434,25 @@ class QueryParamsTrackerService {
     }
     checkRequestOptions(requestOptions = [], options = {}) {
         this.ensureStateRestored();
-        if (!this.ready$.value) {
-            return true;
-        }
-        const normalized = this.normalizeRequestOptions(requestOptions);
-        if (!normalized.pathKey)
-            return false;
-        this.cleanupExpiredEntries();
-        if (!normalized.hasQuery) {
-            const pathState = this.ensurePathState(normalized.pathKey);
-            // Check if we've seen this path before by checking for a special marker
-            const pathSeenBefore = pathState.consumedValuesByKey.hasOwnProperty('__path_seen__');
-            if (!pathSeenBefore) {
-                // Mark this path as seen
-                pathState.consumedValuesByKey['__path_seen__'] = ['true'];
-                this.persistState();
+        return this.ready$.pipe(take(1), map(() => {
+            const normalized = this.normalizeRequestOptions(requestOptions);
+            if (!normalized.pathKey)
+                return false;
+            this.cleanupExpiredEntries();
+            if (!normalized.hasQuery) {
+                const pathState = this.ensurePathState(normalized.pathKey);
+                const pathSeenBefore = pathState.consumedValuesByKey.hasOwnProperty('__path_seen__');
+                if (!pathSeenBefore) {
+                    pathState.consumedValuesByKey['__path_seen__'] = ['true'];
+                    this.persistState();
+                }
+                return !pathSeenBefore;
             }
-            return !pathSeenBefore;
-        }
-        if (options.mode === 'exact') {
-            return this.checkExact(normalized, options);
-        }
-        return this.checkVariation(normalized, options);
+            if (options.mode === 'exact') {
+                return this.checkExact(normalized, options);
+            }
+            return this.checkVariation(normalized, options);
+        }));
     }
     matchesPath(requestOptions = [], expectedPathOptions = []) {
         this.ensureStateRestored();
@@ -7271,99 +7268,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) => {
@@ -7503,62 +7408,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 });
+            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 });
                     }
-                    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 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) {
@@ -7825,6 +7697,130 @@ 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 (async — awaits tracker readiness)
+                    return this.checkTrackerAllowsRequest(this.databaseOptions.table, this.resolvePath(effectiveParams), options, storeData).pipe(switchMap((trackerAllowsRequest) => {
+                        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,
@@ -8496,7 +8492,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,
@@ -8507,12 +8503,12 @@ class HTTPManagerStateService extends ComponentStore {
         if (!normalized.hasQuery || ignoreQueryParams.length === 0) {
             const meta = this.getRequestCacheMetadata(storeData, 'GET');
             console.log('[CacheDebug] checkTrackerAllowsRequest: no query params path', { tableName, requestCacheMeta: meta, allowsRequest: !meta });
-            return !meta;
+            return of(!meta);
         }
         const filtered = this.trackerFilterQuery(normalized.query, ignoreQueryParams);
         const keys = Object.keys(filtered);
         if (keys.length === 0) {
-            return !this.getRequestCacheMetadata(storeData, 'GET');
+            return of(!this.getRequestCacheMetadata(storeData, 'GET'));
         }
         const tracker = this.getTrackerState(storeData);
         const now = Math.floor(Date.now() / 1000);
@@ -8536,7 +8532,7 @@ class HTTPManagerStateService extends ComponentStore {
             }
             this.saveTrackerState(tableName, tracker.consumedValuesByKey, tracker.trackingExpires);
         }
-        return accepted;
+        return of(accepted);
     }
     static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: HTTPManagerStateService, deps: [{ token: API_OPTS }, { token: "dataType" }, { token: DatabaseStorage }], target: i0.ɵɵFactoryTarget.Injectable }); }
     static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: HTTPManagerStateService }); }