http-request-manager 18.15.34 → 18.16.1

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

@@ -1,437 +0,0 @@
-import { DestroyRef, Inject, Injectable, Optional, WritableSignal, signal, computed, effect, inject } from '@angular/core';
-import { takeUntilDestroyed } from '@angular/core/rxjs-interop';
-import { interval } from 'rxjs';
-
-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 { 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 initialState: State = {
-  localStores: [],
-  sessionStores: [],
-  settings: [],
-};
-
-@Injectable({ providedIn: 'root' })
-export class LocalStorageSignalsManagerService {
-
-  private state: WritableSignal<State> = signal(initialState);
-
-  storageName = 'storage';
-  storageSettingsName = 'global-storage';
-  defaultOptions = SettingOptions.adapt();
-
-  stateRetrieved = false;
-  encrypted = false;
-
-  destroyRef = inject(DestroyRef);
-
-  app = inject(AppService);
-  utils = inject(UtilsService);
-  objectMergerService = inject(ObjectMergerService);
-  encryption = inject(SymmetricalEncryptionService);
-  encryptionTest = inject(EncryptionTestService);
-
-  // --- SELECTORS ---
-
-  readonly stores = computed(() => this.state().settings);
-
-  readonly storeExists = (store: string) =>
-    computed(() => !!this.state().settings.find(item => item.name === store));
-
-  readonly store = (store: string) =>
-    computed(() => {
-      const data = this.state();
-      const foundStore = data.settings.find(item => item.name === store);
-      if (!foundStore) return null;
-
-      const options = SettingOptions.adapt(foundStore.options);
-      const found =
-        options.storage === StorageType.GLOBAL
-          ? data.localStores.find(item => item.id === foundStore.id)
-          : data.sessionStores.find(item => item.id === foundStore.id);
-
-      if (!found) {
-        this.deleteStore({ name: store });
-        return null;
-      }
-
-      if (!this.app?.appID) {
-        console.warn('No App ID found - AppId not Provided');
-        return null;
-      }
-
-      let storageData = found.data;
-      if (options.encrypted) {
-        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; // Use undecrypted data as fallback
-          }
-        }
-      }
-
-      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
-      }
-    });
-
-  readonly settings = computed(() => this.state().settings);
-
-  readonly setting = (store: string) =>
-    computed(() => this.state().settings.find(item => item.name === store) ?? null);
-
-  constructor(@Optional() @Inject(CONFIG_SETTINGS_TOKEN) private configOptions?: ConfigOptions) {
-    this.storageName = configOptions?.LocalStorageOptions?.storageName || this.storageName;
-    this.storageSettingsName = configOptions?.LocalStorageOptions?.storageSettingsName || this.storageSettingsName;
-    this.defaultOptions = configOptions?.LocalStorageOptions?.options || this.defaultOptions;
-
-    this.retrieveState();
-    // Auto-persist when state changes
-    effect(() => {
-      if (this.stateRetrieved) {
-        this.persistState(this.state());
-      }
-    });
-
-    // Expiration timer every 3s
-    interval(3000).pipe(takeUntilDestroyed(this.destroyRef)).subscribe(() => {
-      const state = this.state();
-      const expired = this.expired(state);
-      if (expired.length > 0) {
-        const ids = expired.map(i => i.id);
-        const updated: State = {
-          ...state,
-          localStores: state.localStores.filter(i => !ids.includes(i.id)),
-          sessionStores: state.sessionStores.filter(i => !ids.includes(i.id)),
-          settings: state.settings.filter(i => !ids.includes(i.id)),
-        };
-        this.state.set(updated);
-        this.persistState(updated);
-      }
-    });
-  }
-
-  // --- STATE MUTATORS ---
-
-  setStore(store: { id: string; name: string; data: any; options: SettingOptions }) {
-    this.state.update(state => {
-      const settings = StorageOption.adapt(store);
-      settings.options = this.objectMergerService.mergeStorageOptions(settings.options);
-      store.name = this.validStoreName(store.name);
-
-      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;
-
-      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, ...localData],
-        sessionStores: [...state.sessionStores, ...sessionData],
-        settings: [...state.settings, settings],
-      };
-    });
-  }
-
-  createStore(store: { id?: string; name: string; data: any; options: SettingOptions }) {
-    this.state.update(state => {
-      const settings = StorageOption.adapt(store);
-      settings.options = this.objectMergerService.mergeStorageOptions(settings.options);
-
-      if (state.settings.some(item => item.name === store.name)) {
-        return state;
-      }
-
-      if (!this.isObjectOrArray(store.data)) {
-        console.warn('Data must be an Object or Array');
-        return state;
-      }
-
-      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],
-      };
-    });
-  }
-
-  updateStore(store: { name: string; data: any }) {
-    this.state.update(state => {
-      const settings = state.settings.find(item => item.name === store.name);
-      if (!settings) return state;
-
-      const dataStr =
-        settings.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.filter(i => i.id !== settings.id), ...localData],
-        sessionStores: [...state.sessionStores.filter(i => i.id !== settings.id), ...sessionData],
-      };
-    });
-  }
-
-  deleteStore(store: { name: string }) {
-    this.state.update(state => {
-      const id = state.settings.find(item => item.name === store.name)?.id;
-      if (!id) return state;
-      return {
-        ...state,
-        localStores: state.localStores.filter(i => i.id !== id),
-        sessionStores: state.sessionStores.filter(i => i.id !== id),
-        settings: state.settings.filter(i => i.id !== id),
-      };
-    });
-  }
-
-  resetStore() {
-    const cleared: State = { localStores: [], sessionStores: [], settings: [] };
-    this.state.set(cleared);
-    this.persistState(cleared);
-  }
-
-  // --- HELPERS ---
-
-  private persistState(state: State) {
-    localStorage.setItem(this.storageName, JSON.stringify(state.localStores));
-    sessionStorage.setItem(this.storageName, JSON.stringify(state.sessionStores));
-    const settingsStr = this.encryption.encrypt(state.settings, this.app.appID);
-    localStorage.setItem(this.storageSettingsName, settingsStr || '');
-  }
-
-  private expired(state: State) {
-    return state.settings.filter(
-      s => (s.options?.expires || 0) > 0 && this.utils.hasExpired(s.options?.expires!)
-    );
-  }
-
-  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[] = [];
-
-    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: StorageOption[] = [];
-    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 => {
-
-
-      // normalize options so we compare numbers and compute expires correctly
-      const options = SettingOptions.adapt(store.options);
-
-      // if persisted data included expiresIn but not numeric expires, compute it now
-      if ((!options.expires || options.expires === 0) && options.expiresIn) {
-        try {
-          const computed = this.utils.expires(options.expiresIn as string);
-          options.expires = computed || 0;
-        } catch {
-          options.expires = 0;
-        }
-      }
-
-      const expired = (options.expires || 0) > 0 && this.utils.hasExpired(options.expires || 0);
-
-      if (!expired) {
-
-        const hasStorage = this.hasGlobalStorage(options.storage, store.id || '');
-
-        if (!hasStorage) {
-          this.createStore({ id: store.id, name: store.name, data: [], options });
-        } else {
-          const storeData = (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 });
-        }
-
-      }
-
-    });
-
-    this.stateRetrieved = true;
-
-    // Ensure all stored settings have numeric expires computed and persisted
-    try {
-      const current = this.state();
-      let changed = false;
-      const normalizedSettings = current.settings.map(s => {
-        const opts = SettingOptions.adapt(s.options);
-        if ((!opts.expires || opts.expires === 0) && opts.expiresIn) {
-          const computed = this.utils.expires(opts.expiresIn as string) || 0;
-          if (computed && computed !== opts.expires) {
-            opts.expires = computed;
-            changed = true;
-          }
-        }
-        return { ...s, options: opts } as StorageOption;
-      });
-
-      if (changed) {
-        const updated: State = { ...current, settings: normalizedSettings };
-        this.state.set(updated);
-        this.persistState(updated);
-      }
-    } catch (e) {
-      // swallow normalization errors to avoid breaking init
-    }
-
-  }
-
-  private hasGlobalStorage(type: StorageType = StorageType.GLOBAL, id: string) {
-    const strData: StorageData[] = [];
-
-    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;
-  }
-
-  private isObjectOrArray(obj: any) {
-    try {
-      const parsed = typeof obj === 'object' ? obj : JSON.parse(obj);
-      return typeof parsed === 'object' && parsed !== null;
-    } catch {
-      return false;
-    }
-  }
-
-  private isString(obj: any) {
-    return Object.prototype.toString.call(obj) === '[object String]';
-  }
-
-  private validStoreName(str: string) {
-    return str.toLowerCase().replace(/\s+/g, '_').replace(/[^ -~]/g, '');
-  }
-
-  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 {
-      return null;
-    }
-
-    return null;
-  }
-}

package/src/lib/services/local-storage-manager-service/models/global-store-options.model.ts

@@ -1,30 +0,0 @@
-import { StorageOption } from "./storage-option.model"
-
-export interface GlobalStoreOptionsInterface {
-  encryption?: boolean
-  expiresIn?: string
-  expires?: number
-  stores: StorageOption[]|null
-}
-
-export class GlobalStoreOptions implements GlobalStoreOptionsInterface {
-
-  constructor(
-    public encryption = false,
-    public expiresIn?: string,
-    public expires?: number,
-    public stores: StorageOption[]|null = [],
-  ) {}
-
-  static adapt(item?: any): GlobalStoreOptions {
-
-    return new GlobalStoreOptions(
-      (item?.encryption) ? item.encryption : false,
-      (item?.expiresIn) ? item.expiresIn : '',
-      (item?.expires) ? item.expires : 0,
-      (item?.stores) ? item.stores.map((item: any) => StorageOption.adapt(item)) : []
-    )
-
-  }
-
-}

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

@@ -1,6 +0,0 @@
-export * from "./global-store-options.model"
-export * from "./setting-options.model";
-export * from "./storage-data.model";
-export * from "./storage-option.model";
-
-export * from "./storage-type.enum";

package/src/lib/services/local-storage-manager-service/models/setting-options.model.ts

@@ -1,35 +0,0 @@
-import { StorageType } from "./storage-type.enum"
-
-export interface SettingOptionsInterface {
-  storage?: StorageType
-  expires?: number
-  expiresIn?: string
-  encrypted?: boolean
-}
-
-export class SettingOptions implements SettingOptionsInterface {
-
-  constructor(
-    public storage?: StorageType,
-    public expires?: number,
-    public expiresIn?: string,
-    public encrypted?: boolean,
-  ) {}
-
-  static adapt(item?: any): SettingOptions {
-
-    const storage = (typeof item?.storage !== 'undefined' && item?.storage !== null) ? Number(item.storage) : StorageType.GLOBAL;
-    const expires = (typeof item?.expires !== 'undefined' && item?.expires !== null) ? Number(item.expires) : 0;
-    const expiresIn = (typeof item?.expiresIn !== 'undefined' && item?.expiresIn !== null) ? item.expiresIn : '';
-    const encrypted = (typeof item?.encrypted !== 'undefined' && item?.encrypted !== null) ? Boolean(item.encrypted) : false;
-
-    return new SettingOptions(
-      storage,
-      expires,
-      expiresIn,
-      encrypted,
-    )
-
-  }
-
-}

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

@@ -1,24 +0,0 @@
-export interface StorageDataInterface {
-  id?: string
-  data?: any
-}
-
-export class StorageData implements StorageDataInterface {
-
-  constructor(
-    public id?: string,
-    public data?: any,
-  ) {}
-
-  static adapt(item?: any): StorageData {
-
-    return new StorageData(
-      (item?.id) ? item.id : crypto.randomUUID(),
-      (item?.data) ? item.data : null
-    )
-
-  }
-
-}
-
-

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

@@ -1,32 +0,0 @@
-import { SettingOptions } from "./setting-options.model"
-
-export interface StorageOptionInterface {
-  id?: string
-  name: string
-  data?: any
-  options?: SettingOptions
-}
-
-export class StorageOption implements StorageOptionInterface {
-
-  constructor(
-    public id?: string,
-    public name: string = 'untitled',
-    public data?: any,
-    public options?: SettingOptions,
-  ) {}
-
-  static adapt(item?: any): StorageOption {
-
-    return new StorageOption(
-      (item?.id) ? item.id : crypto.randomUUID(),
-      (item?.name) ? item.name.toLowerCase() : 'untitled',
-      item?.data,
-      (item?.options) ? SettingOptions.adapt(item.options) : SettingOptions.adapt(),
-    )
-
-  }
-
-}
-
-

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

@@ -1,5 +0,0 @@
-export enum StorageType {
-  GLOBAL,
-  SESSION,
-  DB
-}