http-request-manager 18.15.13 → 18.15.14

package/fesm2022/http-request-manager.mjs

@@ -6434,31 +6434,25 @@ class QueryParamsTrackerService {
     }
     checkRequestOptions(requestOptions = [], options = {}) {
         this.ensureStateRestored();
-        if (!this.ready$.value) {
-            // 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)
-            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();
@@ -7760,66 +7754,67 @@ class HTTPManagerStateService extends ComponentStore {
                         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 });
+                    // 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();
                             }));
-                        }
-                        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();
                         }));
                     }));
                 }));
@@ -8508,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);
@@ -8537,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 }); }