http-request-manager 18.13.36 → 18.13.38

package/fesm2022/http-request-manager.mjs

@@ -382,7 +382,7 @@ class SymmetricalEncryptionService {
     }
     decrypt(str, key = this.appID) {
         if (!str || key === '')
-            return;
+            return null;
         let _key = CryptoJS.enc.Utf8.parse(key);
         let _iv = CryptoJS.enc.Utf8.parse(key);
         try {
@@ -401,7 +401,10 @@ class SymmetricalEncryptionService {
             return decryptedStr;
         }
         catch (error) {
-            console.error('Decryption failed:', error.message);
+            const message = String(error?.message || '');
+            if (message && !message.includes('Malformed UTF-8 data')) {
+                console.warn('Decryption failed');
+            }
             return null;
         }
         return null;
@@ -5158,13 +5161,18 @@ class LocalStorageManagerService extends ComponentStore {
                 }
                 let storageData = found.data;
                 if (options.encrypted) {
-                    const decryptedData = this.encryption.decrypt(found.data, this.app.appID);
-                    if (decryptedData !== null) {
-                        storageData = decryptedData;
+                    if (this.isString(found.data) && !this.encryptionTest.isEncrypted(found.data)) {
+                        storageData = found.data;
                     }
                     else {
-                        console.warn(`Failed to decrypt data for store: ${store}`);
-                        storageData = found.data;
+                        const decryptedData = this.encryption.decrypt(found.data, this.app.appID);
+                        if (decryptedData !== null) {
+                            storageData = decryptedData;
+                        }
+                        else {
+                            console.warn(`Failed to decrypt data for store: ${store}`);
+                            storageData = found.data;
+                        }
                     }
                 }
                 try {
@@ -5362,34 +5370,31 @@ class LocalStorageManagerService extends ComponentStore {
             sessionData = [];
         }
         if (str) {
-            const decryptedStr = this.encryption.decrypt(str, this.app.appID);
-            if (decryptedStr) {
-                try {
-                    settings = JSON.parse(decryptedStr);
-                }
-                catch (error) {
-                    console.warn('Failed to parse decrypted settings:', error);
-                    settings = [];
+            const plainSettings = this.tryParseSettingsArray(str);
+            if (plainSettings) {
+                settings = plainSettings;
+                const migratedSettings = this.encryption.encrypt(settings, this.app.appID);
+                if (migratedSettings) {
+                    localStorage.setItem(this.storageSettingsName, migratedSettings);
                 }
+                console.warn('Recovered settings from plaintext storage and migrated to encrypted format');
             }
             else {
-                console.warn('Failed to decrypt settings data');
-                try {
-                    const fallbackSettings = JSON.parse(str);
-                    if (Array.isArray(fallbackSettings)) {
-                        settings = fallbackSettings;
-                        const migratedSettings = this.encryption.encrypt(settings, this.app.appID);
-                        if (migratedSettings) {
-                            localStorage.setItem(this.storageSettingsName, migratedSettings);
-                        }
-                        console.warn('Recovered settings from plaintext storage and migrated to encrypted format');
+                const decryptedStr = this.encryption.decrypt(str, this.app.appID);
+                if (decryptedStr) {
+                    const decryptedSettings = this.tryParseSettingsArray(decryptedStr);
+                    if (decryptedSettings) {
+                        settings = decryptedSettings;
                     }
                     else {
+                        console.warn('Failed to parse decrypted settings data. Resetting corrupted settings store.');
+                        localStorage.removeItem(this.storageSettingsName);
                         settings = [];
                     }
                 }
-                catch (error) {
-                    console.warn('Failed to parse settings fallback data:', error);
+                else {
+                    console.warn('Failed to decrypt settings data. Resetting corrupted settings store.');
+                    localStorage.removeItem(this.storageSettingsName);
                     settings = [];
                 }
             }
@@ -5469,16 +5474,16 @@ class LocalStorageManagerService extends ComponentStore {
         try {
             const str = localStorage.getItem(this.storageSettingsName);
             if (str) {
-                // Try to decrypt if it's encrypted
+                const plainSettings = this.tryParseSettingsArray(str);
+                if (plainSettings) {
+                    return false;
+                }
                 const decryptedStr = this.encryption.decrypt(str, this.app.appID);
                 if (decryptedStr !== null && decryptedStr !== undefined) {
-                    // Try to parse the decrypted data
-                    JSON.parse(decryptedStr);
-                }
-                else {
-                    // Decryption failed, data is likely corrupted
-                    return true;
+                    const decryptedSettings = this.tryParseSettingsArray(decryptedStr);
+                    return !decryptedSettings;
                 }
+                return true;
             }
             return false;
         }
@@ -5487,6 +5492,42 @@ class LocalStorageManagerService extends ComponentStore {
             return true;
         }
     }
+    tryParseSettingsArray(raw) {
+        if (!raw) {
+            return null;
+        }
+        if (Array.isArray(raw)) {
+            return raw;
+        }
+        if (!this.isString(raw)) {
+            return null;
+        }
+        try {
+            const parsed = JSON.parse(raw);
+            if (Array.isArray(parsed)) {
+                return parsed;
+            }
+            if (this.isString(parsed)) {
+                const nestedParsed = JSON.parse(parsed);
+                if (Array.isArray(nestedParsed)) {
+                    return nestedParsed;
+                }
+            }
+        }
+        catch {
+            // Continue to fallback parser
+        }
+        try {
+            const fallbackParsed = this.fixAndParseJSON(raw);
+            if (Array.isArray(fallbackParsed)) {
+                return fallbackParsed;
+            }
+        }
+        catch {
+            return null;
+        }
+        return null;
+    }
     static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: LocalStorageManagerService, deps: [{ token: CONFIG_SETTINGS_TOKEN, optional: true }], target: i0.ɵɵFactoryTarget.Injectable }); }
     static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: LocalStorageManagerService, providedIn: 'root' }); }
 }
@@ -5541,13 +5582,18 @@ class LocalStorageSignalsManagerService {
             }
             let storageData = found.data;
             if (options.encrypted) {
-                const decryptedData = this.encryption.decrypt(found.data, this.app.appID);
-                if (decryptedData !== null) {
-                    storageData = decryptedData;
+                if (this.isString(found.data) && !this.encryptionTest.isEncrypted(found.data)) {
+                    storageData = found.data;
                 }
                 else {
-                    console.warn(`Failed to decrypt data for store: ${store}`);
-                    storageData = found.data; // Use undecrypted data as fallback
+                    const decryptedData = this.encryption.decrypt(found.data, this.app.appID);
+                    if (decryptedData !== null) {
+                        storageData = decryptedData;
+                    }
+                    else {
+                        console.warn(`Failed to decrypt data for store: ${store}`);
+                        storageData = found.data; // Use undecrypted data as fallback
+                    }
                 }
             }
             try {
@@ -5682,23 +5728,51 @@ class LocalStorageSignalsManagerService {
         const str = localStorage.getItem(this.storageSettingsName);
         const localStr = localStorage.getItem(this.storageName);
         const sessionStr = sessionStorage.getItem(this.storageName);
-        const localData = localStr ? JSON.parse(localStr) : [];
-        const sessionData = sessionStr ? JSON.parse(sessionStr) : [];
+        let localData = [];
+        let sessionData = [];
+        try {
+            localData = localStr ? JSON.parse(localStr) : [];
+        }
+        catch (error) {
+            console.warn('Failed to parse local storage data:', error);
+            localData = [];
+        }
+        try {
+            sessionData = sessionStr ? JSON.parse(sessionStr) : [];
+        }
+        catch (error) {
+            console.warn('Failed to parse session storage data:', error);
+            sessionData = [];
+        }
         let settings = [];
         if (str) {
-            const decryptedStr = this.encryption.decrypt(str, this.app.appID);
-            if (decryptedStr) {
-                try {
-                    settings = JSON.parse(decryptedStr);
-                }
-                catch (error) {
-                    console.warn('Failed to parse decrypted settings:', error);
-                    settings = [];
+            const plainSettings = this.tryParseSettingsArray(str);
+            if (plainSettings) {
+                settings = plainSettings;
+                const migratedSettings = this.encryption.encrypt(settings, this.app.appID);
+                if (migratedSettings) {
+                    localStorage.setItem(this.storageSettingsName, migratedSettings);
                 }
+                console.warn('Recovered settings from plaintext storage and migrated to encrypted format');
             }
             else {
-                console.warn('Failed to decrypt settings data');
-                settings = [];
+                const decryptedStr = this.encryption.decrypt(str, this.app.appID);
+                if (decryptedStr) {
+                    const decryptedSettings = this.tryParseSettingsArray(decryptedStr);
+                    if (decryptedSettings) {
+                        settings = decryptedSettings;
+                    }
+                    else {
+                        console.warn('Failed to parse decrypted settings data. Resetting corrupted settings store.');
+                        localStorage.removeItem(this.storageSettingsName);
+                        settings = [];
+                    }
+                }
+                else {
+                    console.warn('Failed to decrypt settings data. Resetting corrupted settings store.');
+                    localStorage.removeItem(this.storageSettingsName);
+                    settings = [];
+                }
             }
         }
         settings.forEach(store => {
@@ -5782,6 +5856,33 @@ class LocalStorageSignalsManagerService {
     validStoreName(str) {
         return str.toLowerCase().replace(/\s+/g, '_').replace(/[^ -~]/g, '');
     }
+    tryParseSettingsArray(raw) {
+        if (!raw) {
+            return null;
+        }
+        if (Array.isArray(raw)) {
+            return raw;
+        }
+        if (!this.isString(raw)) {
+            return null;
+        }
+        try {
+            const parsed = JSON.parse(raw);
+            if (Array.isArray(parsed)) {
+                return parsed;
+            }
+            if (this.isString(parsed)) {
+                const nestedParsed = JSON.parse(parsed);
+                if (Array.isArray(nestedParsed)) {
+                    return nestedParsed;
+                }
+            }
+        }
+        catch {
+            return null;
+        }
+        return null;
+    }
     static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: LocalStorageSignalsManagerService, deps: [{ token: CONFIG_SETTINGS_TOKEN, optional: true }], target: i0.ɵɵFactoryTarget.Injectable }); }
     static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: LocalStorageSignalsManagerService, providedIn: 'root' }); }
 }
@@ -6102,7 +6203,7 @@ class DatabaseManagerService extends DbService {
                 console.error(`createTableRecords: DB not open. Cannot write to '${tableName}'.`);
                 return EMPTY;
             }
-            const tableInstance = this.tables.find(t => t.name === tableName);
+            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));
                 return EMPTY;
@@ -6110,17 +6211,49 @@ class DatabaseManagerService extends DbService {
             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.`);
+                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.`);
+                    return from(this.createNewDatabase()).pipe(switchMap(() => writeRecords()));
+                }
+                return writeRecords();
+            }));
+        };
         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.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;
             }));
         }));
     }
+    inferSchemaFromRecords(records) {
+        if (!Array.isArray(records) || records.length === 0) {
+            return null;
+        }
+        const sample = records.find((record) => record && typeof record === 'object');
+        if (!sample) {
+            return null;
+        }
+        const fields = Object.keys(sample)
+            .filter((key) => key !== 'id')
+            .filter((key) => {
+            const value = sample[key];
+            return value === null || ['string', 'number', 'boolean'].includes(typeof value);
+        })
+            .sort();
+        return ['++id', ...fields].join(', ');
+    }
     isMissingObjectStoreError(error) {
         const name = String(error?.name || '').toLowerCase();
         const innerName = String(error?.inner?.name || '').toLowerCase();