http-request-manager 18.15.34 → 18.16.1

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

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

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

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

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

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

@@ -1,33 +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 {
-    // 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

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

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

@@ -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();
-  });
-
-});