http-request-manager 18.13.17 → 18.13.19

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))
@@ -1276,23 +1192,7 @@ class QueryParamsTrackerService {
         }, {}));
     }
     isTrackerState(value) {
-        if (!this.isPlainObject(value) || !this.isPlainObject(value.paths)) {
-            return false;
-        }
-        return Object.keys(value.paths).every((pathKey) => this.isTrackerPathState(value.paths[pathKey]));
-    }
-    isTrackerPathState(value) {
-        if (!this.isPlainObject(value)) {
-            return false;
-        }
-        const hasValidConsumedValues = typeof value.consumedValuesByKey === 'undefined' || this.isPlainObject(value.consumedValuesByKey);
-        const hasValidTrackedAt = typeof value.trackedAt === 'undefined' || typeof value.trackedAt === 'number';
-        const hasValidWatchExpiresAt = typeof value.watchExpiresAt === 'undefined' || typeof value.watchExpiresAt === 'number';
-        const hasValidBaselineQuery = typeof value.baselineQuery === 'undefined' || this.isPlainObject(value.baselineQuery);
-        const hasTrackerMarkers = this.isPlainObject(value.consumedValuesByKey) ||
-            typeof value.trackedAt === 'number' ||
-            this.isPlainObject(value.baselineQuery);
-        return hasValidConsumedValues && hasValidTrackedAt && hasValidWatchExpiresAt && hasValidBaselineQuery && hasTrackerMarkers;
+        return this.isPlainObject(value) && this.isPlainObject(value.paths);
     }
     isPlainObject(value) {
         return Object.prototype.toString.call(value) === '[object Object]';
@@ -5517,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) : [];
@@ -6558,7 +6377,15 @@ class DatabaseManagerService extends DbService {
     }
     createTableRecords(table, records) {
         const tableName = this.cleanTableName(table);
-        return from(this.DBOpened()).pipe(switchMap((opened) => {
+        // Keep full object payload; Dexie stores non-indexed properties as well.
+        const insertRecords = records.map((record) => {
+            const payload = { ...(record || {}) };
+            if (payload.id === undefined || payload.id === null || payload.id === '') {
+                delete payload.id;
+            }
+            return payload;
+        });
+        const writeRecords = () => from(this.DBOpened()).pipe(switchMap((opened) => {
             if (!opened) {
                 console.error(`createTableRecords: DB not open. Cannot write to '${tableName}'.`);
                 return EMPTY;
@@ -6568,17 +6395,28 @@ class DatabaseManagerService extends DbService {
                 return EMPTY;
             }
             const tableInstance = this.table(tableName);
-            // Keep full object payload; Dexie stores non-indexed properties as well.
-            const insertRecords = records.map((record) => {
-                const payload = { ...(record || {}) };
-                if (payload.id === undefined || payload.id === null || payload.id === '') {
-                    delete payload.id;
-                }
-                return payload;
-            });
             console.log(`createTableRecords: Bulk putting ${insertRecords.length} records into ${tableName}`);
             return from(tableInstance.bulkPut(insertRecords)).pipe(map(() => insertRecords));
         }));
+        return writeRecords().pipe(catchError((error) => {
+            if (!this.isMissingObjectStoreError(error)) {
+                throw error;
+            }
+            console.warn(`createTableRecords: Missing object store for '${tableName}'. Waiting for DB readiness and retrying once...`, error);
+            return from(this.createNewDatabase()).pipe(switchMap(() => writeRecords()), catchError((retryError) => {
+                console.error(`createTableRecords: Retry failed for '${tableName}'`, retryError);
+                throw retryError;
+            }));
+        }));
+    }
+    isMissingObjectStoreError(error) {
+        const name = String(error?.name || '').toLowerCase();
+        const innerName = String(error?.inner?.name || '').toLowerCase();
+        const message = String(error?.message || error?.inner?.message || '').toLowerCase();
+        return (name.includes('notfounderror') ||
+            innerName.includes('notfounderror') ||
+            message.includes('object store') ||
+            message.includes('one of the specified object stores was not found'));
     }
     updateTableRecord(table, record) {
         const tableName = this.cleanTableName(table);
@@ -7418,14 +7256,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);
@@ -7435,33 +7273,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([]);
             }));
@@ -7561,17 +7399,24 @@ class HTTPManagerStateService extends ComponentStore {
                 });
             }
         }
-        if (this.apiOptions.ws && this.apiOptions.ws.id !== '') {
+        const wsOptions = this.apiOptions.ws;
+        if (!wsOptions) {
+            this.logger.debug('StateStore', 'WSOptions not provided; skipping WebSocket initialization');
+            return;
+        }
+        const wsId = String(wsOptions.id || '').trim();
+        if (wsId !== '') {
+            wsOptions.id = wsId;
             // Auto-prefix channel ID for private state manager channels
             // This ensures state manager channels are separate from user-defined channels
-            this.apiOptions.ws.id = this.prefixChannel(this.apiOptions.ws.id, ChannelType.STATE);
-            this.logger.debug('StateStore', `🔒 Private state channel configured`, { channelId: this.apiOptions.ws.id });
+            wsOptions.id = this.prefixChannel(wsOptions.id, ChannelType.STATE);
+            this.logger.debug('StateStore', `🔒 Private state channel configured`, { channelId: wsOptions.id });
             // Store our own sessionId for filtering incoming messages
             this.ownSessionId = sessionStorage.getItem('WSID') || null;
             this.logger.debug('StateStore', `🆔 Stored own sessionId for message filtering`, { sessionId: this.ownSessionId });
             this.logger.debug('StateStore', `🔍 WebSocket configuration`, {
-                channelId: this.apiOptions.ws.id,
-                wsServer: this.apiOptions.ws.wsServer,
+                channelId: wsOptions.id,
+                wsServer: wsOptions.wsServer,
                 sessionId: this.ownSessionId,
                 path: this.apiOptions.path
             });
@@ -7583,13 +7428,15 @@ class HTTPManagerStateService extends ComponentStore {
                 // initWS is an effect that triggers when setApiRequestOptions is called with ws config
                 // The effect is already triggered by calling setApiRequestOptions above
             }
-            if (this.apiOptions.ws?.retry) {
-                this.maxRetries = this.apiOptions.ws.retry.times || 3;
-                this.retryDelay = (this.apiOptions.ws.retry.delay && this.apiOptions.ws.retry.delay * 1000) || 5 * 1000;
+            if (wsOptions.retry) {
+                this.maxRetries = wsOptions.retry.times || 3;
+                this.retryDelay = (wsOptions.retry.delay && wsOptions.retry.delay * 1000) || 5 * 1000;
                 this.wsNextRetry.next(this.retryDelay);
             }
             // Validate wsServer before attempting connection
-            if (!this.apiOptions.ws.wsServer || this.apiOptions.ws.wsServer === '') {
+            const wsServer = String(wsOptions.wsServer || '').trim();
+            wsOptions.wsServer = wsServer;
+            if (!wsServer) {
                 this.logger.error('StateStore', 'WSOptions invalid: wsServer is missing or empty');
                 return;
             }
@@ -7602,9 +7449,9 @@ class HTTPManagerStateService extends ComponentStore {
             this.connectionStatusSubscription = this.setupConnectionStatus().subscribe();
             // Make initial connection attempt
             this.logger.debug('StateStore', '🔄 Initial WebSocket connection attempt...');
-            this.httpManagerService.connect(this.apiOptions.ws, this.apiOptions.ws.jwtToken || '');
+            this.httpManagerService.connect(wsOptions, wsOptions.jwtToken || '');
             // Initialize WS effect to handle messages
-            this.initWS(this.apiOptions.ws);
+            this.initWS(wsOptions);
         }
         else {
             this.logger.warn('StateStore', 'WSOptions invalid Id: empty');
@@ -7826,15 +7673,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 {
@@ -8090,8 +7937,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) {
@@ -8106,17 +7952,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;
     }