http-request-manager 18.15.34 → 18.16.1

package/src/lib/services/local-storage-manager-service/local-storage-manager.service.ts

@@ -1,567 +0,0 @@
-import { Inject, Injectable, OnDestroy, Optional, inject } from '@angular/core';
-import { ComponentStore } from '@ngrx/component-store';
-import { withLatestFrom, map, tap } from 'rxjs/operators';
-
-import { UtilsService } from '../utils/utils.service';
-import { SymmetricalEncryptionService } from '../utils/encryption/symmetrical-encryption.service';
-
-import { StorageOption, StorageType } from './models';
-import { SettingOptions } from './models/setting-options.model';
-import { StorageData } from './models/storage-data.model';
-import { EncryptionTestService } from '../utils/encryption/encryption-test.service';
-import { interval } from 'rxjs';
-import { AppService } from '../utils/app.service';
-import { CONFIG_SETTINGS_TOKEN } from '../../models/config-token.model';
-import { ConfigOptions } from '../request-manager-services';
-import { ObjectMergerService } from '../utils/object-merger.service';
-
-export interface State {
-  localStores: StorageData[]
-  sessionStores: StorageData[]
-  settings: StorageOption[]
-}
-
-const storage: State = {
-  localStores: [],
-  sessionStores: [],
-  settings: [],
-};
-
-@Injectable({ providedIn: 'root' })
-export class LocalStorageManagerService extends ComponentStore<State> implements OnDestroy {
-
-  storageName = 'storage'
-  storageSettingsName = 'global-storage'
-  defaultOptions = SettingOptions.adapt()
-
-  stateRetrieved = false
-  encrypted = false
-
-  app = inject(AppService)
-  utils = inject(UtilsService)
-  objectMergerService = inject(ObjectMergerService)
-  encryption = inject(SymmetricalEncryptionService)
-  encryptionTest = inject(EncryptionTestService)
-
-  // SELECTORS
-
-  private readonly data$ = this.select((state) => state)
-
-  readonly stores$ = this.select((state) => state.settings)
-
-  readonly storeExists$ = (store: string) => this.select(
-    this.data$,
-    (data) =>  data.settings.find(item => item.name === store) ? true : false
-  )
-
-  readonly store$ = (store: string) => this.select(
-    this.data$,
-    (data) => {
-      store = store.toLowerCase()
-      const foundStore = [...data.settings].reverse().find(item => item.name === store)
-
-      if(foundStore) {
-
-        const options = SettingOptions.adapt(foundStore.options)
-
-        const found = foundStore.options?.storage === StorageType.GLOBAL
-          ? [...data.localStores].reverse().find(item => item.id === foundStore.id) as StorageData
-          : [...data.sessionStores].reverse().find(item => item.id === foundStore.id) as StorageData
-
-        if(!found) {
-          // console.warn('[CacheDebug] store$: settings entry found but no data entry in localStores/sessionStores', { store, foundStoreId: foundStore.id, storageType: foundStore.options?.storage })
-          this.deleteStore({ name: store })
-          return
-        }
-
-        let storageData = found.data;
-        if (options.encrypted) {
-          if(!this.app?.appID) {
-            console.warn('No App ID found - AppId not Provided, cannot decrypt encrypted store')
-            return
-          }
-
-          if (this.isString(found.data) && !this.encryptionTest.isEncrypted(found.data)) {
-            storageData = found.data;
-          } else {
-            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 {
-          return (this.isString(storageData)) ? JSON.parse(storageData) : storageData;
-        } catch (error) {
-          console.warn(`Failed to parse storage data for store: ${store}`, error);
-          return storageData; // Return raw data if parsing fails
-        }
-
-      } else {
-        return null
-      }
-
-    }
-  )
-
-  readonly settings$ = this.select(state => (state) ? state.settings : storage.settings)
-
-  readonly setting$ = (store: string) => this.select(
-    this.data$,
-    (state) => {
-      const foundSetting = [...state.settings].reverse().find(item => item.name === store)
-      return (foundSetting) ? foundSetting : null
-    }
-  )
-
-  persistence$ = this.data$
-  .subscribe(data => {
-    if(this.stateRetrieved) this.persistState(data)
-  })
-
-  startTimer() {
-    const timer$ = interval(1000 * 3).pipe(
-      withLatestFrom(this.data$),
-      map(([_, state]) => state),
-      tap((state) => {
-
-        const expired: StorageOption[] = this.expired(state) ? this.expired(state) : []
-
-        if (expired.length > 0) {
-
-          const ids = expired.map((item) => item.id)
-
-          const updatedState: State = {
-            ...state,
-            localStores: state.localStores.filter((item) => !ids.includes(item.id)),
-            sessionStores: state.sessionStores.filter((item) => !ids.includes(item.id)),
-            settings: state.settings.filter((item) => !ids.includes(item.id)),
-          };
-
-          this.persistState(updatedState)
-          this.updateState(updatedState)
-
-        }
-      })
-    );
-
-    timer$.subscribe()
-  }
-
-  private updateState = this.updater((state, updatedState: State) => ({
-    ...updatedState,
-  }))
-
-
-  constructor(@Optional() @Inject(CONFIG_SETTINGS_TOKEN) private configOptions?: ConfigOptions) {
-
-    super(storage)
-
-    this.storageName = configOptions?.LocalStorageOptions?.storageName || this.storageName
-    this.storageSettingsName = configOptions?.LocalStorageOptions?.storageSettingsName || this.storageSettingsName
-    this.defaultOptions = configOptions?.LocalStorageOptions?.options || this.defaultOptions
-
-    this.retrieveState()
-    this.startTimer()
-  }
-
-  readonly setStore = this.updater((state: State, store: { id: string, name: string, data: any, options: SettingOptions }): any => {
-
-    const settings = StorageOption.adapt(store)
-    store.name = store.name.toLowerCase()
-    settings.options = this.objectMergerService.mergeStorageOptions(settings.options)
-
-    const type = store.options.storage
-    const hasStore = this.hasGlobalStorage(type, store.id)
-
-    store.name = this.validStoreName(store.name)
-
-    if(!hasStore) {
-      // console.warn(`No such Store: ${store.name}`)
-      return state
-    } else {
-
-    const str = this.encryptionTest.isEncrypted(store.data) ? store.data : JSON.stringify(store.data)
-    const dataStr = (this.isObjectOrArray(str)) ? (store.options.encrypted) ? this.encryption.encrypt(str, this.app.appID) : store.data : store.data
-
-    const localData = (dataStr && settings.options?.storage === StorageType.GLOBAL) ? [{ data: dataStr, id: settings.id }] : []
-    const sessionData = (dataStr && settings.options?.storage === StorageType.SESSION) ? [{ data: dataStr, id: settings.id }] : []
-    const localStores = state.localStores.filter(item => item.id !== settings.id)
-    const sessionStores = state.sessionStores.filter(item => item.id !== settings.id)
-    const stateSettings = state.settings.filter(item => item.id !== settings.id)
-
-    return {
-      ...state,
-      localStores: [...localStores, ...localData],
-      sessionStores: [...sessionStores, ...sessionData],
-      settings: [...stateSettings, ...[settings]],
-      }
-
-    }
-
-  })
-
-  readonly createStore = this.updater((state: State, store: { id?: string, name: string, data: any, options: SettingOptions }): any => {
-
-    store.name = store.name.toLowerCase()
-    store.options = this.objectMergerService.mergeStorageOptions(store.options)
-    const settings = StorageOption.adapt(store)
-    settings.options = this.objectMergerService.mergeStorageOptions(settings.options)
-    const foundStore = state?.settings.some(item => item.name === store.name)
-
-    const expires = (settings.options?.expiresIn) ? this.utils.expires(settings.options?.expiresIn) : 0
-    if(settings.options) settings.options.expires = expires
-
-    store.name = this.validStoreName(store.name)
-
-    if(foundStore) {
-      return state
-    } else {
-      if(!this.isObjectOrArray(store.data)) {
-        console.warn('Data must ba an Object or Array')
-        return
-      }
-
-      store.data = (this.isString(store.data)) ? JSON.parse(store.data) : store.data
-      const dataStr = (store.options.encrypted) ? this.encryption.encrypt(store.data, this.app.appID) : store.data
-
-      const localData = (settings.options?.storage === StorageType.GLOBAL) ? [{ data: dataStr, id: settings.id }] : []
-      const sessionData = (settings.options?.storage === StorageType.SESSION) ? [{ data: dataStr, id: settings.id }] : []
-
-      return {
-        ...state,
-        localStores: [...state.localStores, ...localData],
-        sessionStores: [...state.sessionStores, ...sessionData],
-        settings: [...state.settings, ...[settings]],
-        }
-
-    }
-
-  })
-
-  readonly updateStore = this.updater((state: State, store: { name: string, data: any }): any => {
-
-    store.name = store.name.toLowerCase()
-    store.name = this.validStoreName(store.name)
-
-    const settings = [...state.settings].reverse().find(item => item.name === store.name)
-
-    if(settings) {
-
-      const dataStr = (settings.options?.encrypted) ? this.encryption.encrypt(store.data, this.app.appID) : store.data
-
-      const localData = (dataStr && settings.options?.storage === StorageType.GLOBAL) ? [{ data: dataStr, id: settings.id }] : []
-      const sessionData = (dataStr && settings.options?.storage === StorageType.SESSION) ? [{ data: dataStr, id: settings.id }] : []
-
-      return {
-        ...state,
-        localStores: [...state.localStores.filter(item => item.id !== settings.id), ...localData],
-        sessionStores: [...state.sessionStores.filter(item => item.id !== settings.id), ...sessionData],
-      }
-    }
-
-    return state
-
-  })
-
-  readonly deleteStore = this.updater((state: State, store: { name: string }): any => {
-
-    store.name = store.name.toLowerCase()
-    store.name = this.validStoreName(store.name)
-
-    const id = state.settings.find(item => item.name === store.name)?.id
-
-    if(id) {
-
-      const settings = state.settings.filter(item => item.id !== id)
-      const localData = state.localStores.filter(item => item.id !== id)
-      const sessionData = state.sessionStores.filter(item => item.id !== id)
-
-      return {
-        ...state,
-        localStores: [...localData],
-        sessionStores: [...sessionData],
-        settings: [...settings],
-        }
-
-    } else {
-      // console.warn(`No such Store: ${store.name}`)
-      return state
-    }
-
-  })
-
-  resetStore() {
-
-    const newState = {
-      localStores: [],
-      sessionStores: [],
-      settings: [],
-      }
-
-      this.updateState(newState)
-      this.persistState(newState)
-
-  }
-
-  private persistState(state: State|null) {
-
-    if(!state) return
-
-    const strLocal = JSON.stringify(state.localStores)
-    localStorage.setItem(this.storageName, strLocal)
-
-    const strSession = JSON.stringify(state.sessionStores)
-    sessionStorage.setItem(this.storageName, strSession)
-
-    const settingsStr = this.encryption.encrypt(state.settings, this.app.appID)
-    localStorage.setItem(this.storageSettingsName, settingsStr || '')
-
-  }
-
-  private expired(state: State|null) {
-
-    if(!state) return []
-    return state.settings?.filter(item => (item.options?.expires || 0) > 0 && this.utils.hasExpired(item.options?.expires || 0))
-
-  }
-
-  retrieveState() {
-
-    const str = localStorage.getItem(this.storageSettingsName)
-
-    const localStr = localStorage.getItem(this.storageName)
-    const sessionStr = sessionStorage.getItem(this.storageName)
-
-    let localData: StorageData[] = [];
-    let sessionData: StorageData[] = [];
-    let settings: StorageOption[] = [];
-
-    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 = [];
-    }
-
-    if (str) {
-      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 {
-        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 => {
-
-      const expired =  (store.options?.expires || 0) > 0 && this.utils.hasExpired(store.options?.expires || 0)
-
-      if(!expired) {
-
-        const hasStorage = this.hasGlobalStorage(store.options?.storage, store.id || '')
-
-        if(!hasStorage) {
-          this.createStore({ id: store.id, name: store.name, data: [], options: SettingOptions.adapt(store.options)})
-        } else {
-          const storeData = (store.options?.storage === StorageType.GLOBAL) ? localData.find(item => item.id === store.id) : sessionData.find(item => item.id === store.id)
-          this.setStore({ id: store.id || '', name: store.name, data: storeData?.data, options: SettingOptions.adapt(store.options) })
-        }
-
-      }
-
-    })
-
-    this.stateRetrieved = true
-
-  }
-
-  private isObjectOrArray = (obj: any) => {
-
-    let parsed;
-
-    try {
-      parsed = (typeof obj === 'object') ? obj : JSON.parse(obj)
-    } catch (e) {
-      return false;
-    }
-
-    if (Array.isArray(parsed)) {
-      const allStringsOrObjectsOrNumbers = parsed.every(item =>
-          typeof item === 'string' ||
-          typeof item === 'object' && item !== null ||
-          typeof item === 'number'
-      );
-      return allStringsOrObjectsOrNumbers;
-    }
-
-    return typeof parsed === 'object' && parsed !== null;
-
-  }
-
-  private isString (obj: any) {
-    return (Object.prototype.toString.call(obj) === '[object String]')
-  }
-
-  private fixAndParseJSON(jsonString: string): any {
-    const fixedString = jsonString
-      .replace(/'/g, '"')
-      .replace(/([{,]\s*)(\w+)\s*:/g, '$1"$2":')
-      .replace(/,\s*(\}|\])/g, '$1');
-
-    try {
-      return JSON.parse(fixedString);
-    } catch (error: any) {
-      throw new Error('Failed to parse JSON: ' + error.message);
-    }
-  }
-
-  private validStoreName(str: string) {
-    return str
-      .toLowerCase() // Convert to lowercase
-      .replace(/\s+/g, '_') // Replace spaces with underscores
-      .replace(/[^ -~]/g, ''); // Remove non-ASCII characters
-  }
-
-  private hasGlobalStorage(type: StorageType = StorageType.GLOBAL, id: string) {
-
-    const strData: StorageOption[] = []
-
-    if(type === StorageType.GLOBAL) {
-      const str = localStorage.getItem(this.storageName)
-      strData.push(...(str ? JSON.parse(str) : []))
-    } else {
-      const str = sessionStorage.getItem(this.storageName)
-      strData.push(...(str ? JSON.parse(str) : []))
-    }
-
-    const found = strData.find(store => store.id === id)
-    return (found) ? true : false
-
-  }
-
-  override ngOnDestroy() {
-    this.persistence$.unsubscribe()
-  }
-
-  /**
-   * Clears all stored data from localStorage and sessionStorage
-   * Use this method to recover from corrupted data errors
-   */
-  clearAllStoredData(): void {
-    try {
-      // Use resetStore() instead of directly removing raw localStorage keys.
-      // clearAllStoredData previously only removed the raw localStorage entries, leaving
-      // the ComponentStore's in-memory BehaviorSubject untouched. Any subsequent call to
-      // store$(name) would read from the in-memory state and return the old (stale) data,
-      // because store$ is a ComponentStore selector — it reads from in-memory state, not
-      // from raw localStorage. This caused stale requestCache / queryParams to persist
-      // after a deleteDatabase() call, blocking all subsequent API requests.
-      // resetStore() correctly updates both the in-memory state AND persists to localStorage.
-      this.resetStore();
-      console.log('Cleared all stored data');
-    } catch (error) {
-      console.error('Failed to clear stored data:', error);
-    }
-  }
-
-  /**
-   * Checks if stored data appears to be corrupted
-   * Returns true if data appears corrupted
-   */
-  checkForCorruptedData(): boolean {
-    try {
-      const str = localStorage.getItem(this.storageSettingsName);
-      if (str) {
-        const plainSettings = this.tryParseSettingsArray(str);
-        if (plainSettings) {
-          return false;
-        }
-
-        const decryptedStr = this.encryption.decrypt(str, this.app.appID);
-        if (decryptedStr !== null && decryptedStr !== undefined) {
-          const decryptedSettings = this.tryParseSettingsArray(decryptedStr);
-          return !decryptedSettings;
-        }
-
-        return true;
-      }
-      return false;
-    } catch (error) {
-      // Parsing failed, data is corrupted
-      return true;
-    }
-  }
-
-  private tryParseSettingsArray(raw: any): StorageOption[] | null {
-    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;
-  }
-
-}

package/src/lib/services/local-storage-manager-service/local-storage-signals-manager.service.spec.ts

@@ -1,67 +0,0 @@
-import { TestBed } from '@angular/core/testing';
-import { LocalStorageSignalsManagerService } from './local-storage-signals-manager.service';
-import { UtilsService } from '../utils/utils.service';
-import { SymmetricalEncryptionService } from '../utils/encryption/symmetrical-encryption.service';
-import { EncryptionTestService } from '../utils/encryption/encryption-test.service';
-import { AppService } from '../utils/app.service';
-import { ObjectMergerService } from '../utils/object-merger.service';
-
-describe('LocalStorageSignalsManagerService (signals)', () => {
-  let service: LocalStorageSignalsManagerService;
-  let utilsService: jasmine.SpyObj<UtilsService>;
-  let encryptionService: jasmine.SpyObj<SymmetricalEncryptionService>;
-  let encryptionTestService: jasmine.SpyObj<EncryptionTestService>;
-  let appService: jasmine.SpyObj<AppService>;
-  let objectMergerService: jasmine.SpyObj<ObjectMergerService>;
-
-  beforeEach(() => {
-    localStorage.clear();
-    sessionStorage.clear();
-
-    const utilsSpy = jasmine.createSpyObj('UtilsService', ['expires', 'hasExpired', 'generateUUID']);
-    const encryptionSpy = jasmine.createSpyObj('SymmetricalEncryptionService', ['encrypt', 'decrypt']);
-    const encryptionTestSpy = jasmine.createSpyObj('EncryptionTestService', ['isEncrypted']);
-    const appServiceSpy = jasmine.createSpyObj('AppService', [], { appID: 'test-app-id' });
-    const objectMergerSpy = jasmine.createSpyObj('ObjectMergerService', ['mergeStorageOptions']);
-
-    utilsSpy.generateUUID.and.returnValue('test-uuid');
-
-    TestBed.configureTestingModule({
-      providers: [
-        LocalStorageSignalsManagerService,
-        { provide: UtilsService, useValue: utilsSpy },
-        { provide: SymmetricalEncryptionService, useValue: encryptionSpy },
-        { provide: EncryptionTestService, useValue: encryptionTestSpy },
-        { provide: AppService, useValue: appServiceSpy },
-        { provide: ObjectMergerService, useValue: objectMergerSpy }
-      ]
-    });
-
-  service = TestBed.inject(LocalStorageSignalsManagerService);
-    utilsService = TestBed.inject(UtilsService) as jasmine.SpyObj<UtilsService>;
-    encryptionService = TestBed.inject(SymmetricalEncryptionService) as jasmine.SpyObj<SymmetricalEncryptionService>;
-    encryptionTestService = TestBed.inject(EncryptionTestService) as jasmine.SpyObj<EncryptionTestService>;
-    appService = TestBed.inject(AppService) as jasmine.SpyObj<AppService>;
-    objectMergerService = TestBed.inject(ObjectMergerService) as jasmine.SpyObj<ObjectMergerService>;
-
-    // Setup default spy behaviors
-    utilsService.hasExpired.and.returnValue(false);
-    utilsService.expires.and.returnValue(0);
-    encryptionTestService.isEncrypted.and.returnValue(false);
-    encryptionService.encrypt.and.returnValue('encrypted');
-    encryptionService.decrypt.and.returnValue('{}');
-
-    // Ensure empty initial state via the public API
-    service.resetStore();
-  });
-
-  afterEach(() => {
-    localStorage.clear();
-    sessionStorage.clear();
-  });
-
-  it('should be created', () => {
-    expect(service).toBeTruthy();
-  });
-
-});