http-request-manager 18.15.32 → 18.15.34

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

@@ -0,0 +1,240 @@
+import { Injectable } from '@angular/core';
+import Dexie, { Table } from 'dexie';
+import { from, Observable, of } from 'rxjs';
+import { catchError, map, switchMap } from 'rxjs/operators';
+
+@Injectable({
+  providedIn: 'root',
+})
+export class DbService extends Dexie {
+
+  readonly storageDB = "global_storage_db"
+
+  get db() { return this; }
+
+  private dbReady: Promise<void>;
+
+  constructor() {
+
+    super("global_storage_db");
+
+    this.on('blocked', () => {
+        console.warn('Database upgrade blocked! Please close other tabs/windows of this app.');
+    });
+
+    this.on('versionchange', () => {
+      console.warn('Database version changed in another tab. Closing current database connection to allow upgrade.');
+      this.close();
+    });
+
+    this.dbReady = this.init();
+
+  }
+
+  private async init() {
+    try {
+      // Check if database already exists
+      const dbExists = await Dexie.exists(this.storageDB);
+
+      if (dbExists) {
+        // Database exists - just open it without declaring version
+        // This allows Dexie to use the existing schema and version
+        console.log(`Database "${this.storageDB}" already exists. Opening with existing schema...`);
+
+        if (!this.isOpen()) {
+          await this.open();
+        }
+
+        console.log(`✅ Connected to existing database. Current version: ${this.verno}`);
+        console.log(`📊 Existing tables: ${this.getTables.join(', ')}`);
+      } else {
+        // New database - initialize with empty schema at version 1
+        console.log(`Creating new database "${this.storageDB}"...`);
+
+        if (this.isOpen()) {
+          this.close();
+        }
+
+        this.version(1).stores({});
+        await this.open();
+        console.log(`✅ New database initialized. Current version: ${this.verno}`);
+      }
+    } catch (err) {
+      console.error('Failed to initialize database:', err);
+      throw err;
+    }
+  }
+
+  protected async createNewDatabase() {
+    if (this.isOpen()) {
+      this.close();
+    }
+    await this.open();
+  }
+
+  get vr() {
+    return this.verno;
+  }
+
+  get nextVr() {
+    const v = this.verno;
+    return (isNaN(v) || v === 0) ? 1 : v + 1;
+  }
+
+  get getTables() {
+    return this.tables.map((table) => table.name);
+  }
+
+  async hasDatabase() {
+    return await Dexie.exists(this.storageDB);
+  }
+
+  getTable(tableName: string): Table<any, any> | undefined {
+    try {
+        return this.table(tableName);
+    } catch (error) {
+        return undefined;
+    }
+  }
+
+  tableExists(tableName: string): boolean {
+    return this.tables.some(t => t.name === tableName);
+  }
+
+  protected async updateTable(tableName: string, find: { key: string, value: string | number }, data: any): Promise<boolean> {
+    const table = this.getTable(tableName);
+    if (!table || !find || !find.key) return false;
+
+    try {
+      const count = await table.where(find.key).equals(find.value).modify(data);
+      return count > 0;
+    } catch (error) {
+      console.error('Error updating table:', error);
+      return false;
+    }
+  }
+
+  protected async createTable(tableName: string, schema: string) {
+    if (!tableName || !schema) return;
+    this.dbReady = this.dbReady.then(() => this._doCreateTable(tableName, schema));
+    await this.dbReady;
+  }
+
+  private async _doCreateTable(tableName: string, schema: string): Promise<void> {
+    const safeTableName = this.cleanTableName(tableName);
+    const safeSchema = schema.trim();
+
+    const currentSchema = this.getCurrentSchema();
+    const existingSchema = currentSchema[safeTableName]?.trim();
+
+    if (this.tableExists(safeTableName) && existingSchema === safeSchema) {
+      return;
+    }
+
+    console.log('Current Schema before update:', currentSchema);
+
+    currentSchema[safeTableName] = safeSchema;
+
+    const nextVersion = this.verno + 1;
+    console.log(`Creating table ${safeTableName}. Upgrading to version ${nextVersion}. New Schema:`, currentSchema);
+
+    if (this.isOpen()) {
+      this.close();
+    }
+
+    this.version(nextVersion).stores(currentSchema);
+
+    try {
+        await this.open();
+        const created = this.tables.some(t => t.name === safeTableName);
+        if (!created) {
+         console.error(`CRITICAL: Table ${safeTableName} was NOT created after upgrade! Tables found:`, this.tables.map(t => t.name));
+         throw new Error(`Table '${safeTableName}' was not created after schema upgrade`);
+        } else {
+             console.log(`Database opened successfully version ${this.verno}. Table ${safeTableName} verified.`);
+        }
+    } catch (err) {
+        console.error('Error opening database after schema update:', err);
+      throw err;
+    }
+  }
+
+  protected async DBOpened() {
+    try {
+      await this.dbReady;
+      return this.isOpen();
+    } catch (err) {
+      console.error('DBOpened: init failed', err);
+      return false;
+    }
+  }
+
+  private getCurrentSchema(): { [key: string]: string } {
+    const schema: { [key: string]: string } = {};
+
+    if (!this.tables || this.tables.length === 0) {
+        return schema;
+    }
+
+    this.tables.forEach(table => {
+      const primKey = table.schema.primKey;
+      const indexes = table.schema.indexes;
+
+      let schemaStr = "";
+
+      if (primKey.auto) schemaStr += "++";
+
+      if (Array.isArray(primKey.keyPath)) {
+          schemaStr += `[${primKey.keyPath.join('+')}]`;
+      } else {
+          schemaStr += primKey.keyPath || "";
+      }
+
+      indexes.forEach(idx => {
+        schemaStr += ",";
+        if (idx.unique) schemaStr += "&";
+        if (idx.multi) schemaStr += "*";
+
+        if (Array.isArray(idx.keyPath)) {
+            schemaStr += `[${idx.keyPath.join('+')}]`;
+        } else {
+            schemaStr += idx.keyPath || "";
+        }
+      });
+
+      schema[table.name] = schemaStr;
+    });
+    return schema;
+  }
+
+  protected deleteAndReinitialize(): Observable<boolean> {
+    return from(
+      this.delete({ disableAutoOpen: false }).then(async () => {
+        console.log('[DB] Database deleted. Reopening...');
+        try {
+          await this.open();
+          this.dbReady = Promise.resolve();
+          console.log(`[DB] Reopened database. Version: ${this.verno}, Tables: ${this.getTables.join(', ')}`);
+          return this.isOpen();
+        } catch (openErr) {
+          console.error('[DB] Failed to reopen after delete:', openErr);
+          return false;
+        }
+      })
+    ).pipe(
+      catchError((err) => {
+        console.error('[DB] deleteAndReinitialize failed:', err);
+        return of(false);
+      })
+    );
+  }
+
+  protected cleanTableName(str: string): string {
+    return str
+      .replace(/[^a-zA-Z0-9\s_]/g, '')
+      .replace(/\s+/g, '_')
+      .trim()
+      .toLowerCase();
+  }
+
+}

package/src/lib/services/database-manager-service/index.ts

@@ -0,0 +1,4 @@
+export * from "./models/index";
+
+export * from "./database.manager.service";
+export * from "./db.storage.service";

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

@@ -0,0 +1,2 @@
+export * from "./table-schema";
+

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

@@ -0,0 +1,33 @@
+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 {
+    // Allow alphanumeric, spaces, underscores, and Dexie schema characters (+, &, *, [, ])
+    const cleanStr = str
+      .replace(/[^a-zA-Z0-9\s_+\&*\[\]]/g, '')
+      .trim();
+
+    return cleanStr;
+  }
+
+}

package/src/lib/services/index.ts

@@ -0,0 +1,20 @@
+
+// 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";
+
+// Explicitly re-export to avoid conflicts
+export { WebSocketMessageService } from "./ws-manager-service/index";
+export { StateMessage, StateMessageInterface } from "./ws-manager-service/index";
+export { PublicMessage, PublicMessageInterface } from "./ws-manager-service/index";
+export { NotificationMessage, NotificationMessageInterface } from "./ws-manager-service/index";
+// ChannelType is already exported from request-manager-state-service
+
+export * from "./store-state-manager-service/index";
+export * from "./database-manager-service/index";
+export * from "./SQL-DixieJS service/index";
+
+
+export * from "./utils/index";

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

@@ -0,0 +1,4 @@
+export * from "./models/index";
+
+export * from "./local-storage-manager.service";
+export { LocalStorageSignalsManagerService } from "./local-storage-signals-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();
+  });
+
+});