http-request-manager 18.15.17 → 18.15.20

package/fesm2022/http-request-manager.mjs

@@ -6127,13 +6127,18 @@ class DbService extends Dexie {
         return schema;
     }
     deleteAndReinitialize() {
-        return from(Dexie.delete(this.storageDB).then(async () => {
-            if (this.isOpen()) {
-                this.close();
+        return from(this.delete({ disableAutoOpen: false }).then(async () => {
+            console.log('[DB] Database deleted. Reopening...');
+            try {
+                await this.open();
+                this.dbReady = Promise.resolve();
+                console.log(`[DB] Reopened database. Version: ${this.verno}, Tables: ${this.getTables.join(', ')}`);
+                return this.isOpen();
+            }
+            catch (openErr) {
+                console.error('[DB] Failed to reopen after delete:', openErr);
+                return false;
             }
-            this.dbReady = this.init();
-            await this.dbReady;
-            return this.isOpen();
         })).pipe(catchError((err) => {
             console.error('[DB] deleteAndReinitialize failed:', err);
             return of(false);
@@ -6466,34 +6471,33 @@ 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(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;
             }
-            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();
-        const requestPath = this.normalizeRequestOptions(requestOptions).pathKey;
-        const expectedPath = this.normalizeRequestOptions(expectedPathOptions).pathKey;
-        return Boolean(requestPath) && requestPath === expectedPath;
+        return this.ready$.pipe(filter(ready => ready === true), take(1), map(() => {
+            const requestPath = this.normalizeRequestOptions(requestOptions).pathKey;
+            const expectedPath = this.normalizeRequestOptions(expectedPathOptions).pathKey;
+            return Boolean(requestPath) && requestPath === expectedPath;
+        }));
     }
     checkExact(normalized, options) {
         const pathState = this.ensurePathState(normalized.pathKey);
@@ -7339,56 +7343,57 @@ 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()));
                             }
-                            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 this.checkTrackerAllowsRequest(this.databaseOptions.table, this.resolvePath(effectiveParams), options, storeData).pipe(switchMap((trackerAllowsRequest) => {
+                                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.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();
                                 }));
                             }));
                         }));
@@ -7571,25 +7576,26 @@ 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(() => 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();
+                    return this.checkTrackerAllowsRequest(this.databaseOptions.table, this.resolvePath(effectiveParams), options, storeData).pipe(switchMap((trackerAllowsRequest) => {
+                        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)
@@ -8501,7 +8507,7 @@ class HTTPManagerStateService extends ComponentStore {
         if (!Array.isArray(ignoreQueryParams))
             return { ...query };
         if (ignoreQueryParams.length === 0)
-            return {};
+            return { ...query };
         const result = {};
         ignoreQueryParams.forEach((param) => {
             const key = this.trackerNormalizeParamKey(param);
@@ -8536,15 +8542,14 @@ class HTTPManagerStateService extends ComponentStore {
         }
         const normalized = this.trackerNormalizePath(path);
         const ignoreQueryParams = Array.isArray(options?.ignoreQueryParams) ? options.ignoreQueryParams : [];
-        if (!normalized.hasQuery || ignoreQueryParams.length === 0) {
+        if (!normalized.hasQuery) {
             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);
@@ -8568,7 +8573,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 }); }