http-request-manager 18.15.15 → 18.15.17

package/fesm2022/http-request-manager.mjs

@@ -6126,6 +6126,19 @@ class DbService extends Dexie {
         });
         return schema;
     }
+    deleteAndReinitialize() {
+        return from(Dexie.delete(this.storageDB).then(async () => {
+            if (this.isOpen()) {
+                this.close();
+            }
+            this.dbReady = this.init();
+            await this.dbReady;
+            return this.isOpen();
+        })).pipe(catchError((err) => {
+            console.error('[DB] deleteAndReinitialize failed:', err);
+            return of(false);
+        }));
+    }
     cleanTableName(str) {
         return str
             .replace(/[^a-zA-Z0-9\s_]/g, '')
@@ -6273,10 +6286,26 @@ class DatabaseManagerService extends DbService {
             if (!this.isMissingObjectStoreError(error)) {
                 throw error;
             }
-            // console.warn(`createTableRecords: Missing object store for '${tableName}'. Recreating table and retrying once...`, error);
             return recreateMissingTableAndRetry().pipe(catchError((retryError) => {
-                console.error(`createTableRecords: Retry failed for '${tableName}'`, retryError);
-                throw retryError;
+                if (!this.isMissingObjectStoreError(retryError)) {
+                    console.error(`createTableRecords: Retry failed for '${tableName}'`, retryError);
+                    throw retryError;
+                }
+                console.warn(`createTableRecords: Table '${tableName}' still missing after retry. Deleting DB and reinitializing...`);
+                return this.deleteAndReinitialize().pipe(switchMap((reinitialized) => {
+                    if (!reinitialized) {
+                        throw retryError;
+                    }
+                    const inferredSchema = this.inferSchemaFromRecords(insertRecords);
+                    if (!inferredSchema) {
+                        throw retryError;
+                    }
+                    const tableDef = TableSchemaDef.adapt({ table: tableName, schema: inferredSchema });
+                    return this.createDatabaseTable(tableDef).pipe(switchMap(() => writeRecords()));
+                }), catchError((finalError) => {
+                    console.error(`createTableRecords: All retries exhausted for '${tableName}'`, finalError);
+                    throw finalError;
+                }));
             }));
         }));
     }
@@ -6369,6 +6398,9 @@ class DatabaseManagerService extends DbService {
             return of(false);
         })).subscribe();
     }
+    resetDatabase() {
+        return this.deleteAndReinitialize();
+    }
     static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: DatabaseManagerService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
     static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: DatabaseManagerService, providedIn: 'root' }); }
 }
@@ -6434,25 +6466,28 @@ class QueryParamsTrackerService {
     }
     checkRequestOptions(requestOptions = [], options = {}) {
         this.ensureStateRestored();
-        return this.ready$.pipe(filter(ready => ready === true), 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;
-            }
-            if (options.mode === 'exact') {
-                return this.checkExact(normalized, options);
+        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.checkVariation(normalized, options);
-        }));
+            return !pathSeenBefore;
+        }
+        if (options.mode === 'exact') {
+            return this.checkExact(normalized, options);
+        }
+        return this.checkVariation(normalized, options);
     }
     matchesPath(requestOptions = [], expectedPathOptions = []) {
         this.ensureStateRestored();
@@ -7268,7 +7303,99 @@ class HTTPManagerStateService extends ComponentStore {
                 table: this.databaseOptions?.table,
                 databaseOptions: this.databaseOptions
             });
-            return this.resolveCacheDecision('GET', requestOptions, effectiveParams, options, fetchFromAPI);
+            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();
         })));
         // 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) => {
@@ -7408,29 +7535,62 @@ class HTTPManagerStateService extends ComponentStore {
             const requestOptions = this.updateRequestOptions(options?.headers);
             requestOptions.stream = true;
             const effectiveParams = this.getEffectiveParams(options?.path);
-            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 });
+            // 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 });
                     }
-                    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) => {
+                    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()));
+                    }
+                    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) => {
                     const res = packet?.data;
                     // console.log('[DEBUG] Streaming response received:', res)
                     if (res && res.length > 0) {
@@ -7697,130 +7857,6 @@ 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,
@@ -8492,7 +8528,7 @@ class HTTPManagerStateService extends ComponentStore {
         return Math.floor(Date.now() / 1000) + Number(parsed[1]) * seconds;
     }
     checkTrackerAllowsRequest(tableName, path, options, storeData) {
-        if (options && Array.isArray(options.watchParams)) {
+        if (options && 'watchParams' in options) {
             return this.queryParamsTrackerService.checkRequestOptions(path, {
                 watchParams: options.watchParams,
                 watchExpiresAt: options?.watchExpiresAt,
@@ -8503,12 +8539,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 of(!meta);
+            return !meta;
         }
         const filtered = this.trackerFilterQuery(normalized.query, ignoreQueryParams);
         const keys = Object.keys(filtered);
         if (keys.length === 0) {
-            return of(!this.getRequestCacheMetadata(storeData, 'GET'));
+            return !this.getRequestCacheMetadata(storeData, 'GET');
         }
         const tracker = this.getTrackerState(storeData);
         const now = Math.floor(Date.now() / 1000);
@@ -8532,7 +8568,7 @@ class HTTPManagerStateService extends ComponentStore {
             }
             this.saveTrackerState(tableName, tracker.consumedValuesByKey, tracker.trackingExpires);
         }
-        return of(accepted);
+        return 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 }); }