http-request-manager 18.15.6 → 18.15.8

package/fesm2022/http-request-manager.mjs

@@ -1933,8 +1933,8 @@ class WebSocketManagerService {
         WebSocketManagerService.socket.onmessage = (event) => {
             try {
                 const data = JSON.parse(event.data);
-                if (data.error && data.error === 'JWT_INVALID') {
-                    console.error('JWT validation failed. Authentication error!');
+                if (data.error && (data.error === 'JWT_INVALID' || data.error === 'AUTH_BLOCKED')) {
+                    console.error(`🚫 ${data.error}: ${data.message || 'Authentication error'}`);
                     WebSocketManagerService.jwtInvalidClose = true;
                     WebSocketManagerService.messages.next(data);
                     WebSocketManagerService.connectionStatus.next(false);
@@ -6241,27 +6241,27 @@ class DatabaseManagerService extends DbService {
         });
         const writeRecords = () => from(this.DBOpened()).pipe(switchMap((opened) => {
             if (!opened) {
-                console.error(`createTableRecords: DB not open. Cannot write to '${tableName}'.`);
+                // console.error(`createTableRecords: DB not open. Cannot write to '${tableName}'.`);
                 return EMPTY;
             }
             const tableInstance = this.getTable(tableName);
             if (!tableInstance) {
-                console.error(`createTableRecords: Table '${tableName}' does not exist in DB version ${this.verno}. Available:`, this.tables.map(t => t.name));
+                // console.error(`createTableRecords: Table '${tableName}' does not exist in DB version ${this.verno}. Available:`, this.tables.map(t => t.name));
                 return EMPTY;
             }
-            console.log(`createTableRecords: Bulk putting ${insertRecords.length} records into ${tableName}`);
+            // console.log(`createTableRecords: Bulk putting ${insertRecords.length} records into ${tableName}`);
             return from(tableInstance.bulkPut(insertRecords)).pipe(map(() => insertRecords));
         }));
         const recreateMissingTableAndRetry = () => {
             const inferredSchema = this.inferSchemaFromRecords(insertRecords);
             if (!inferredSchema) {
-                console.warn(`createTableRecords: Could not infer schema for '${tableName}'. Retrying after DB reopen.`);
+                // console.warn(`createTableRecords: Could not infer schema for '${tableName}'. Retrying after DB reopen.`);
                 return from(this.createNewDatabase()).pipe(switchMap(() => writeRecords()));
             }
             const tableDef = TableSchemaDef.adapt({ table: tableName, schema: inferredSchema });
             return this.createDatabaseTable(tableDef).pipe(switchMap((created) => {
                 if (!created) {
-                    console.warn(`createTableRecords: Failed to recreate table '${tableName}' from inferred schema. Retrying after DB reopen.`);
+                    // console.warn(`createTableRecords: Failed to recreate table '${tableName}' from inferred schema. Retrying after DB reopen.`);
                     return from(this.createNewDatabase()).pipe(switchMap(() => writeRecords()));
                 }
                 return writeRecords();
@@ -6271,7 +6271,7 @@ class DatabaseManagerService extends DbService {
             if (!this.isMissingObjectStoreError(error)) {
                 throw error;
             }
-            console.warn(`createTableRecords: Missing object store for '${tableName}'. Recreating table and retrying once...`, 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;
@@ -6814,6 +6814,7 @@ class HTTPManagerStateService extends ComponentStore {
             'if-none-match'
         ]);
         this.requestSignatureCache = {};
+        this.inFlightRequestSignatures = new Set();
         this._requestCachePaths = new Map();
         this.wsRetryAttempts = new BehaviorSubject(0);
         this.wsRetryAttempts$ = this.wsRetryAttempts.asObservable();
@@ -7207,6 +7208,18 @@ class HTTPManagerStateService extends ComponentStore {
             const fetchFromAPI = () => {
                 if (this.hasDatabase && this.databaseOptions?.table) {
                     this.setCachedRequestSignature(this.databaseOptions.table, 'GET', requestSignature);
+                    if (!this.tryBeginInFlightRequest(requestSignature)) {
+                        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 ? [] : {});
+                    }
                 }
                 return this.httpManagerService.getRequest(requestOptions, effectiveParams).pipe(tap((data) => {
                     // Extract array from paginated response if needed
@@ -7245,6 +7258,10 @@ class HTTPManagerStateService extends ComponentStore {
                         }));
                     }
                     return of(data);
+                }), finalize(() => {
+                    if (this.hasDatabase && this.databaseOptions?.table) {
+                        this.endInFlightRequest(requestSignature);
+                    }
                 }));
             };
             console.log('[DB STORAGE] Checking database storage:', {
@@ -7487,23 +7504,38 @@ class HTTPManagerStateService extends ComponentStore {
             // 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 });
+                    }
+                    this.setCachedRequestSignature(this.databaseOptions.table, 'STREAM', requestSignature);
+                    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) {
-                        this.setCachedRequestSignature(this.databaseOptions.table, 'STREAM', requestSignature);
-                        return this.httpManagerService.getRequest(requestOptions, effectiveParams).pipe(map((apiData) => ({ data: apiData, fromCache: false })));
+                        return fetchStreamFromAPI();
                     }
                     if (hasExpired) {
-                        return this.dbManagerService.clearTable(this.databaseOptions.table).pipe(tap(() => this.setCachedRequestSignature(this.databaseOptions.table, 'STREAM', requestSignature)), switchMap(() => this.httpManagerService.getRequest(requestOptions, effectiveParams)), map((apiData) => ({ data: apiData, fromCache: false })));
+                        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)), tap(() => this.setCachedRequestSignature(this.databaseOptions.table, 'STREAM', requestSignature)), switchMap(() => this.httpManagerService.getRequest(requestOptions, effectiveParams)), map((apiData) => ({ data: apiData, fromCache: false })));
+                        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) {
@@ -7523,8 +7555,7 @@ class HTTPManagerStateService extends ComponentStore {
                             return of({ data: this.dataType === DataType.ARRAY ? [] : {}, fromCache: true });
                         }));
                     }
-                    this.setCachedRequestSignature(this.databaseOptions.table, 'STREAM', requestSignature);
-                    return this.httpManagerService.getRequest(requestOptions, effectiveParams).pipe(map((apiData) => ({ data: apiData, fromCache: false })));
+                    return fetchStreamFromAPI();
                 })).pipe(tap((packet) => {
                     const res = packet?.data;
                     // console.log('[DEBUG] Streaming response received:', res)
@@ -8285,6 +8316,16 @@ class HTTPManagerStateService extends ComponentStore {
             [type]: signature,
         };
     }
+    tryBeginInFlightRequest(signature) {
+        if (this.inFlightRequestSignatures.has(signature)) {
+            return false;
+        }
+        this.inFlightRequestSignatures.add(signature);
+        return true;
+    }
+    endInFlightRequest(signature) {
+        this.inFlightRequestSignatures.delete(signature);
+    }
     getRequestCacheMetadata(storeData, type) {
         return storeData?.requestCache?.[type] || null;
     }