http-request-manager 15.0.24 → 15.0.26

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

@@ -0,0 +1,191 @@
+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/{lib/services/database-manager-services/index.d.ts → src/lib/services/database-manager-services/index.ts}

@@ -1,3 +1,4 @@
 export * from "./models/table-schema";
+
 export * from "./database.manager.service";
 export * from "./db.storage.service";

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

@@ -0,0 +1,35 @@
+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/{lib/services/index.d.ts → src/lib/services/index.ts}

@@ -1,4 +1,8 @@
+
+// export * from "./database-manager-services/index";
 export * from "./local-storage-manager-service/index";
+
 export * from "./request-manager-services/index";
 export * from "./request-manager-state-service/index";
+
 export * from "./utils/index";

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

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

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

@@ -0,0 +1,71 @@
+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();
+  });
+
+});