http-request-manager 15.0.26 → 18.0.1

package/src/lib/services/database-manager-services/db.storage.service.ts

@@ -1,191 +0,0 @@
-import { Injectable } from '@angular/core';
-import Dexie, {Table} from 'dexie';
-
-@Injectable({
-  providedIn: 'root',
-})
-export class DbService extends Dexie {
-
-  storageDB = "global_storage_db"
-
-  db = new Dexie(this.storageDB)
-
-  get vr() {
-    return (this.db.verno === 0) ? 1 : this.db.verno + 1
-  }
-
-  get nextVr() {
-    return this.vr + 1
-  }
-
-  get getTables() {
-    return this.db.tables.map(item => item.name)
-  }
-
-  async hasDatabase() {
-    return await Dexie.exists(this.storageDB).then((res) => {
-      this.createNewDatabase()
-      return res
-    })
-  }
-
-  getTable = (table: string) => {
-    return this.db.tables.find(item => item.name === table)
-  }
-
-  tableExists = (table: string) => {
-    return (this.getTables.find(item => item === table)) ? true : false
-  }
-
-  constructor() {
-
-      super("global_storage_db")
-
-      this.db = this
-      this.open().then(data => {
-
-      }).catch(err => {
-        this.createNewDatabase()
-      })
-
-  }
-
-  protected async updateTable(table: string, find: { key: string, value: string|number }, data: any) {
-
-    const tableSource = this.getTable(table)
-
-    if(!tableSource || !find || !(find.key || find.value)) return false
-
-    await tableSource?.where(find.key).equals(find.value).first()
-    .then(async (rec: any) => {
-      const newRec = this.updateObjectKeys(rec, data)
-      await tableSource?.update(rec.id, newRec)
-    })
-
-    return true
-
-  }
-
-  protected async createNewDatabase() {
-
-    const db = new Dexie('global_storage_db');
-
-    if (!await Dexie.exists(db.name)) {
-      db.version(1).stores({})
-    }
-
-    await db.open()
-
-  }
-
-  // async createTable(table: string, schema: string) {
-  protected async createTable(table: string, schema: string) {
-
-    // console.log('createTable:', table, schema)
-
-    this.hasDatabase().then(async(res) => {
-
-      const tableDef = this.normalizeString(table)
-      const schemaDef = this.normalizeString(schema)
-
-      table = tableDef || ''
-      schema = schemaDef || ''
-
-      if(table === '' || schema === '') return
-
-      if(!this.db.isOpen()) {
-        await this.db.open()
-        .then( async () => {
-          this.create(table, schema)
-          // console.log('OPENED', table)
-        })
-        .catch(() => {
-          // console.log('FAILED', table)
-        })
-
-      } else {
-        this.create(table, schema)
-      }
-
-      const hasTable = this.getTable(table)
-
-      if(!hasTable) {
-        setTimeout(() => {
-          this.createTable.bind(this, table, schema)
-          this.create(table, schema)
-        }, 300)
-      }
-
-      // console.log('DB HAS', table, hasTable)
-
-    })
-
-  }
-
-  private async create(table: string, schema: string) {
-
-    // console.log('OPEN', this.db.name, this.vr, this.db.verno, 'OPEN',this.db.isOpen())
-
-    if(!this.tableExists(table)) {
-
-      if(this.db.isOpen()) await this.db.close()
-
-      const newSchema: any = { [table]: schema }
-      await this.db.version(this.nextVr).stores(newSchema)
-
-      // console.log('Created New Table: ', table, schema)
-
-      if(!this.db.isOpen()) await this.db.open()
-    }
-
-  }
-
-  private updateObjectKeys(obj1: any, obj2: any) {
-
-    return Object.keys(obj1).reduce((updatedObj: any, key: any) => {
-      updatedObj[key] = obj2.hasOwnProperty(key) ? obj2[key] : obj1[key]
-      return updatedObj
-    }, {})
-
-  }
-
-  protected async DBOpened() {
-
-    if(!this.db.isOpen()) {
-      await this.db.open()
-      .then( async () => {
-        // console.log('OPENED')
-      })
-      .catch(async (err) => {
-        // console.log('OPENED ERR')
-        return false
-      })
-    } else {
-      // console.log('OPENED')
-    }
-
-    return true
-
-  }
-
-  private normalizeString(item: string|string[]) {
-
-    if(!item) return
-
-    return Array.isArray(item) ?
-      item.map((item: string) => this.cleanString(item)).join()
-      : item.split(',').map((item: string) => this.cleanString(item)).join()
-
-  }
-
-  private cleanString(str: string): string {
-
-    const cleanStr = str
-      .replace(/[^a-zA-Z0-9\s]/g, '')
-      .replace(/\s+/g, '_')
-
-      return cleanStr.trim().toLowerCase()
-
-  }
-
-}

package/src/lib/services/database-manager-services/models/table-schema.ts

@@ -1,35 +0,0 @@
-export interface TableSchemaDefInterface {
-  table: string
-  schema: string
-}
-
-export class TableSchemaDef implements TableSchemaDefInterface {
-  constructor(
-    public table = 'unknown',
-    public schema: string = '',
-  ) {}
-
-  static adapt(item?: any): TableSchemaDef {
-
-    const schemaArray = (item?.schema && Array.isArray(item.schema)) ? item.schema : item.schema.split(',')
-    const schema = schemaArray.map((item: string) => this.cleanString(item)).join()
-
-    return new TableSchemaDef(
-      (item?.table) ? this.cleanString(item.table) : 'unknown',
-      schema,
-    )
-
-  }
-
-  static cleanString(str: string): string {
-    const camelCaseSplit = str.replace(/([a-z])([A-Z])/g, '$1 $2')
-  
-    const cleanStr = camelCaseSplit
-      .replace(/[^a-zA-Z0-9\s]/g, '')  // Remove non-alphanumeric characters except spaces
-      .toLowerCase()                   // Convert to lowercase
-      .trim();                         // Trim any leading or trailing spaces
-  
-    return cleanStr;
-  }
-
-}

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

@@ -1,2 +0,0 @@
-export * from "./models/index"
-export * from "./local-storage-manager.service";

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

@@ -1,71 +0,0 @@
-import { TestBed } from '@angular/core/testing';
-import { LocalStorageManagerService } from './local-storage-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('LocalStorageManagerService', () => {
-  let service: LocalStorageManagerService;
-  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: [
-        LocalStorageManagerService,
-        { provide: UtilsService, useValue: utilsSpy },
-        { provide: SymmetricalEncryptionService, useValue: encryptionSpy },
-        { provide: EncryptionTestService, useValue: encryptionTestSpy },
-        { provide: AppService, useValue: appServiceSpy },
-        { provide: ObjectMergerService, useValue: objectMergerSpy }
-      ]
-    });
-
-    service = TestBed.inject(LocalStorageManagerService);
-    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('{}');
-
-    // Initialize the store with empty state
-    service.setState({
-      localStores: [],
-      sessionStores: [],
-      settings: []
-    });
-  });
-
-  afterEach(() => {
-    localStorage.clear();
-    sessionStorage.clear();
-  });
-
-  it('should be created', () => {
-    expect(service).toBeTruthy();
-  });
-
-});