http-request-manager 18.13.16 → 18.13.18

package/fesm2022/http-request-manager.mjs

@@ -876,14 +876,13 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImpo
         }], ctorParameters: () => [] });
 
 class PathTrackerStateModel {
-    constructor(baselineQuery, consumedValuesByKey = {}, watchExpiresAt, trackedAt) {
+    constructor(baselineQuery, consumedValuesByKey = {}, watchExpiresAt) {
         this.baselineQuery = baselineQuery;
         this.consumedValuesByKey = consumedValuesByKey;
         this.watchExpiresAt = watchExpiresAt;
-        this.trackedAt = trackedAt;
     }
     static adapt(item) {
-        return new PathTrackerStateModel(item?.baselineQuery, item?.consumedValuesByKey, item?.watchExpiresAt, item?.trackedAt);
+        return new PathTrackerStateModel(item?.baselineQuery, item?.consumedValuesByKey, item?.watchExpiresAt);
     }
 }
 
@@ -904,15 +903,14 @@ class QueryTrackerStateModel {
 const TRACKER_STORE_NAME = 'query_params_tracker';
 const TRACKER_SESSION_INIT_KEY = 'query_params_tracker_initialized';
 const DEFAULT_TRACKER_OPTIONS = SettingOptions.adapt({
-    storage: StorageType.SESSION,
+    storage: StorageType.GLOBAL,
     encrypted: false,
-    expiresIn: '1d',
 });
 class QueryParamsTrackerService {
     constructor() {
-        this.localStorageManager = inject(LocalStorageManagerService);
         this.state = { paths: {} };
         this.stateRestored = false;
+        this.localStorageManager = inject(LocalStorageManagerService);
     }
     clearTracking(resetSessionInit = false) {
         this.state = { paths: {} };
@@ -923,18 +921,12 @@ class QueryParamsTrackerService {
     }
     checkRequestOptions(requestOptions = [], options = {}) {
         this.ensureStateRestored();
-        this.tryHydrateStateFromPersistedStore();
         const normalized = this.normalizeRequestOptions(requestOptions);
         if (!normalized.pathKey)
             return false;
         this.cleanupExpiredEntries();
         if (!normalized.hasQuery) {
-            const pathExists = !!this.state.paths[normalized.pathKey];
-            if (pathExists) {
-                return false;
-            }
-            const pathState = this.ensurePathState(normalized.pathKey);
-            pathState.trackedAt = Math.floor(Date.now() / 1000);
+            this.ensurePathState(normalized.pathKey);
             this.persistState();
             return true;
         }
@@ -945,7 +937,6 @@ class QueryParamsTrackerService {
     }
     matchesPath(requestOptions = [], expectedPathOptions = []) {
         this.ensureStateRestored();
-        this.tryHydrateStateFromPersistedStore();
         const requestPath = this.normalizeRequestOptions(requestOptions).pathKey;
         const expectedPath = this.normalizeRequestOptions(expectedPathOptions).pathKey;
         return Boolean(requestPath) && requestPath === expectedPath;
@@ -1057,31 +1048,13 @@ class QueryParamsTrackerService {
         }
     }
     normalizePath(pathSegments) {
-        const normalizedSegments = pathSegments
-            .map((segment) => this.extractPathFromSegment(segment))
-            .flatMap((segment) => segment.split('/'))
+        return pathSegments
             .map((segment) => String(segment).trim())
-            .filter((segment) => segment.length > 0);
-        // Treat leading "rest" as transport/base-path noise for stable cache keys.
-        if (normalizedSegments[0]?.toLowerCase() === 'rest') {
-            normalizedSegments.shift();
-        }
-        return normalizedSegments.join('/');
-    }
-    extractPathFromSegment(segment) {
-        const raw = String(segment).trim();
-        if (!raw) {
-            return '';
-        }
-        try {
-            if (/^https?:\/\//i.test(raw)) {
-                return new URL(raw).pathname;
-            }
-        }
-        catch {
-            return raw;
-        }
-        return raw;
+            .filter((segment) => segment.length > 0)
+            .join('/')
+            .replace(/([^:]\/+)\/+/g, '$1')
+            .replace(/^\//, '')
+            .replace(/\/$/, '');
     }
     normalizeParamKey(key) {
         return String(key).trim().toLowerCase();
@@ -1146,8 +1119,7 @@ class QueryParamsTrackerService {
             }
             const hasBaseline = Boolean(pathState.baselineQuery && Object.keys(pathState.baselineQuery).length > 0);
             const hasTrackedValues = Object.keys(pathState.consumedValuesByKey).some((key) => (pathState.consumedValuesByKey[key] || []).length > 0);
-            const isNoQueryTracked = Boolean(pathState.trackedAt);
-            if (!hasBaseline && !hasTrackedValues && !isNoQueryTracked) {
+            if (!hasBaseline && !hasTrackedValues) {
                 delete this.state.paths[pathKey];
             }
         });
@@ -1176,20 +1148,14 @@ class QueryParamsTrackerService {
         if (initialized === '1') {
             return;
         }
+        this.clearTracking();
         sessionStorage.setItem(TRACKER_SESSION_INIT_KEY, '1');
     }
     restoreState() {
-        this.tryHydrateStateFromPersistedStore();
-        if (Object.keys(this.state.paths).length > 0) {
-            return;
-        }
         this.localStorageManager.store$(TRACKER_STORE_NAME)
             .pipe(take(1))
             .subscribe({
             next: (storedState) => {
-                if (Object.keys(this.state.paths).length > 0) {
-                    return;
-                }
                 if (this.isTrackerState(storedState)) {
                     this.state = QueryTrackerStateModel.adapt(storedState);
                     this.cleanupExpiredEntries();
@@ -1198,60 +1164,10 @@ class QueryParamsTrackerService {
                 this.state = { paths: {} };
             },
             error: () => {
-                if (Object.keys(this.state.paths).length === 0) {
-                    this.state = { paths: {} };
-                }
+                this.state = { paths: {} };
             }
         });
     }
-    tryHydrateStateFromPersistedStore() {
-        if (Object.keys(this.state.paths).length > 0) {
-            return;
-        }
-        const syncState = this.localStorageManager.getPersistedStoreSync(TRACKER_STORE_NAME);
-        if (this.isTrackerState(syncState)) {
-            this.state = QueryTrackerStateModel.adapt(syncState);
-            this.cleanupExpiredEntries();
-            return;
-        }
-        const fallbackState = this.getTrackerStateFromRawStorage();
-        if (!this.isTrackerState(fallbackState)) {
-            return;
-        }
-        this.state = QueryTrackerStateModel.adapt(fallbackState);
-        this.cleanupExpiredEntries();
-    }
-    getTrackerStateFromRawStorage() {
-        const rawSources = [
-            this.safeParseRawStorage(localStorage.getItem('storage')),
-            this.safeParseRawStorage(sessionStorage.getItem('storage')),
-        ];
-        for (const source of rawSources) {
-            if (!Array.isArray(source)) {
-                continue;
-            }
-            for (const entry of source) {
-                if (this.isTrackerState(entry?.data)) {
-                    return entry.data;
-                }
-                if (this.isTrackerState(entry)) {
-                    return entry;
-                }
-            }
-        }
-        return null;
-    }
-    safeParseRawStorage(value) {
-        if (!value) {
-            return null;
-        }
-        try {
-            return JSON.parse(value);
-        }
-        catch {
-            return null;
-        }
-    }
     persistState() {
         this.localStorageManager.storeExists$(TRACKER_STORE_NAME)
             .pipe(take(1))
@@ -5501,87 +5417,6 @@ const storage = {
     settings: [],
 };
 class LocalStorageManagerService extends ComponentStore {
-    getStoreSync(storeName) {
-        storeName = storeName.toLowerCase();
-        const data = this.get();
-        const foundStore = data.settings.find(item => item.name === storeName);
-        if (!foundStore) {
-            return null;
-        }
-        const found = foundStore.options?.storage === StorageType.GLOBAL
-            ? data.localStores.find(item => item.id === foundStore.id)
-            : data.sessionStores.find(item => item.id === foundStore.id);
-        if (!found || !this.app?.appID) {
-            return null;
-        }
-        const options = SettingOptions.adapt(foundStore.options);
-        let storageData = found.data;
-        if (options.encrypted) {
-            const decryptedData = this.encryption.decrypt(found.data, this.app.appID);
-            if (decryptedData !== null) {
-                storageData = decryptedData;
-            }
-        }
-        try {
-            return this.isString(storageData) ? JSON.parse(storageData) : storageData;
-        }
-        catch {
-            return storageData;
-        }
-    }
-    getPersistedStoreSync(storeName) {
-        storeName = this.validStoreName(String(storeName || ''));
-        if (!storeName || !this.app?.appID) {
-            return null;
-        }
-        const settingsStr = localStorage.getItem(this.storageSettingsName);
-        if (!settingsStr) {
-            return null;
-        }
-        let settings = [];
-        try {
-            const decryptedSettings = this.encryption.decrypt(settingsStr, this.app.appID);
-            settings = decryptedSettings ? JSON.parse(decryptedSettings) : [];
-        }
-        catch {
-            return null;
-        }
-        const foundSetting = settings.find(item => item.name === storeName);
-        if (!foundSetting) {
-            return null;
-        }
-        const rawStores = foundSetting.options?.storage === StorageType.GLOBAL
-            ? localStorage.getItem(this.storageName)
-            : sessionStorage.getItem(this.storageName);
-        if (!rawStores) {
-            return null;
-        }
-        let stores = [];
-        try {
-            stores = JSON.parse(rawStores);
-        }
-        catch {
-            return null;
-        }
-        const foundStore = stores.find(item => item.id === foundSetting.id);
-        if (!foundStore) {
-            return null;
-        }
-        const options = SettingOptions.adapt(foundSetting.options);
-        let storageData = foundStore.data;
-        if (options.encrypted) {
-            const decryptedData = this.encryption.decrypt(foundStore.data, this.app.appID);
-            if (decryptedData !== null) {
-                storageData = decryptedData;
-            }
-        }
-        try {
-            return this.isString(storageData) ? JSON.parse(storageData) : storageData;
-        }
-        catch {
-            return storageData;
-        }
-    }
     startTimer() {
         const timer$ = interval(1000 * 3).pipe(withLatestFrom(this.data$), map(([_, state]) => state), tap((state) => {
             const expired = this.expired(state) ? this.expired(state) : [];
@@ -7402,14 +7237,14 @@ class HTTPManagerStateService extends ComponentStore {
                     return this.httpManagerService.getRequest(requestOptions, effectiveParams).pipe(map((apiData) => ({ data: apiData, fromCache: false })));
                 })).pipe(tap((packet) => {
                     const res = packet?.data;
-                    // console.log('[DEBUG] Streaming response received:', res)
+                    console.log('[DEBUG] Streaming response received:', res);
                     if (res && res.length > 0) {
-                        // console.log('[DEBUG] Updating state with streaming data:', res)
+                        console.log('[DEBUG] Updating state with streaming data:', res);
                         this.setData$(res);
                         this.streamedResponse = res;
                     }
                     else {
-                        // console.log('[DEBUG] No streaming data or empty array:', res)
+                        console.log('[DEBUG] No streaming data or empty array:', res);
                     }
                     // Reset pending once we have a response packet (cache or network)
                     this.httpManagerService.isPending.next(false);
@@ -7419,33 +7254,33 @@ class HTTPManagerStateService extends ComponentStore {
                     }
                     return this.persistStreamDataToDb(packet?.data, options);
                 }), map((res) => {
-                    // console.log('[DEBUG] Returning data to subscribers:', res)
+                    console.log('[DEBUG] Returning data to subscribers:', res);
                     return res;
                 }), catchError((error) => {
-                    // console.error('[DEBUG] Streaming error:', error)
+                    console.error('[DEBUG] Streaming error:', error);
                     this.httpManagerService.isPending.next(false);
                     return of([]);
                 }));
             }
             return this.httpManagerService.getRequest(requestOptions, effectiveParams)
                 .pipe(tap((res) => {
-                // console.log('[DEBUG] Streaming response received:', res)
+                console.log('[DEBUG] Streaming response received:', res);
                 // Always update state with streaming data
                 if (res && res.length > 0) {
-                    // console.log('[DEBUG] Updating state with streaming data:', res)
+                    console.log('[DEBUG] Updating state with streaming data:', res);
                     this.setData$(res);
                     this.streamedResponse = res;
                 }
                 else {
-                    // console.log('[DEBUG] No streaming data or empty array:', res)
+                    console.log('[DEBUG] No streaming data or empty array:', res);
                 }
                 // Reset pending once we have a response packet
                 this.httpManagerService.isPending.next(false);
             }), concatMap((res) => this.persistStreamDataToDb(res, options)), map((res) => {
-                // console.log('[DEBUG] Returning data to subscribers:', res)
+                console.log('[DEBUG] Returning data to subscribers:', res);
                 return res; // Return the data so subscribers can receive it
             }), catchError((error) => {
-                // console.error('[DEBUG] Streaming error:', error)
+                console.error('[DEBUG] Streaming error:', error);
                 this.httpManagerService.isPending.next(false);
                 return of([]);
             }));
@@ -7810,15 +7645,15 @@ class HTTPManagerStateService extends ComponentStore {
                 return;
             }
             // DEBUG: Log what we're sending
-            // console.log('🔍 [DEBUG] sendWsCommunication called:', {
-            //   wsServer,
-            //   wsServerType: typeof wsServer,
-            //   wsServerEmpty: wsServer === '' || wsServer === null || wsServer === undefined,
-            //   method,
-            //   path,
-            //   user: this.apiOptions.ws.user,
-            //   fullPayload: { method, path, user: this.apiOptions.ws.user }
-            // });
+            console.log('🔍 [DEBUG] sendWsCommunication called:', {
+                wsServer,
+                wsServerType: typeof wsServer,
+                wsServerEmpty: wsServer === '' || wsServer === null || wsServer === undefined,
+                method,
+                path,
+                user: this.apiOptions.ws.user,
+                fullPayload: { method, path, user: this.apiOptions.ws.user }
+            });
             this.httpManagerService.sendMessageInChannel(wsServer, { method, path, user: this.apiOptions.ws.user });
         }
         else {
@@ -8074,8 +7909,7 @@ class HTTPManagerStateService extends ComponentStore {
         if (!this.hasDatabase || !this.databaseOptions?.table)
             return;
         const tableName = this.databaseOptions.table;
-        this.dbManagerService.clearTable(tableName)
-            .subscribe({
+        this.dbManagerService.clearTable(tableName).subscribe({
             next: () => {
                 this.clearRequestCacheMetadata(tableName);
                 if (this.dataType === DataType.ARRAY) {
@@ -8090,17 +7924,6 @@ class HTTPManagerStateService extends ComponentStore {
             }
         });
     }
-    clearTable(tableName) {
-        this.dbManagerService.clearTable(tableName)
-            .subscribe({
-            next: () => {
-                this.clearRequestCacheMetadata(tableName);
-            },
-            error: (err) => {
-                console.error(`❌ Error clearing table ${tableName}:`, err);
-            }
-        });
-    }
     isEmpty(obj) {
         return Object.keys(obj).length === 0;
     }