http-request-manager 15.0.24 → 15.0.26

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

@@ -0,0 +1,421 @@
+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) => {
+
+      const foundStore = data.settings.find(item => item.name === store)
+
+      if(foundStore) {
+
+        const options = SettingOptions.adapt(foundStore.options)
+
+        const found = foundStore.options?.storage === StorageType.GLOBAL
+          ? data.localStores.find(item => item.id === foundStore.id) as StorageData
+          : data.sessionStores.find(item => item.id === foundStore.id) as StorageData
+
+        if(!found) {
+          this.deleteStore({ name: store })
+          return
+        }
+
+        if(!this.app?.appID) {
+          console.warn('No App ID found - AppId not Provided')
+          return
+        }
+
+        const storageData = (options.encrypted) ? this.encryption.decrypt(found.data, this.app.appID) : found.data
+        return (this.isString(storageData)) ? JSON.parse(storageData): storageData
+
+      } 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.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)
+    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 }] : []
+
+    return {
+      ...state,
+      localStores: [...state.localStores, ...localData],
+      sessionStores: [...state.sessionStores, ...sessionData],
+      settings: [...state.settings, ...[settings]],
+      }
+
+    }
+
+  })
+
+  readonly createStore = this.updater((state: State, store: { id?: string, name: string, data: any, options: SettingOptions }): any => {
+
+    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 = this.validStoreName(store.name)
+
+      const settings = state.settings.find(item => item.name === store.name)
+
+      if(settings) {
+
+        const type = settings.options?.storage
+        const hasStore = this.hasGlobalStorage(type, settings.id || '')
+
+        if(!hasStore) {
+          console.warn(`No such Store: ${store.name}`)
+        } else {
+
+        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 }] : []
+
+        state.localStores = state.localStores.filter(item => item.id !== settings.id)
+        state.sessionStores = state.sessionStores.filter(item => item.id !== settings.id)
+
+        return {
+          ...state,
+          localStores: [...state.localStores, ...localData],
+          sessionStores: [...state.sessionStores, ...sessionData],
+          }
+
+        }
+      }
+
+    return state
+
+  })
+
+  readonly deleteStore = this.updater((state: State, store: { name: string }): any => {
+
+    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)
+
+    const localData: StorageData[] = (localStr) ? JSON.parse(localStr) : null
+    const sessionData: StorageData[] = (sessionStr) ? JSON.parse(sessionStr) : null
+
+    const decryptedStr = str ? this.encryption.decrypt(str, this.app.appID) : null
+    const settings: StorageOption[] = (decryptedStr && decryptedStr !== null) ? JSON.parse(decryptedStr) : []
+
+    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()
+  }
+
+}

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

@@ -0,0 +1,30 @@
+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/{lib/services/local-storage-manager-service/models/index.d.ts → src/lib/services/local-storage-manager-service/models/index.ts}

@@ -1,5 +1,6 @@
-export * from "./global-store-options.model";
+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

@@ -0,0 +1,30 @@
+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 {
+
+    return new SettingOptions(
+      (item?.storage) ? item.storage : StorageType.GLOBAL,
+      (item?.expires) ? item.expires : 0,
+      (item?.expiresIn) ? item.expiresIn : '',
+      (item?.encrypted) ? item?.encrypted : false,
+    )
+
+  }
+
+}

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

@@ -0,0 +1,24 @@
+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

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

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

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