ihm_client/src/services/credentials/storage.service.ts

/**
 * StorageService - Gestion du stockage des credentials de pairing
 * Utilisé uniquement pour stocker les credentials après le processus de pairing
 */
import { secureLogger } from '../secure-logger';
import { CredentialData } from './types';
import { DATABASE_CONFIG } from '../database-config';

export class StorageService {
  private static instance: StorageService;
  private dbName = DATABASE_CONFIG.name;
  private storeName = DATABASE_CONFIG.stores.credentials.name; // Store pour les credentials de pairing
  private dbVersion = DATABASE_CONFIG.version;

  private constructor() {}

  public static getInstance(): StorageService {
    if (!StorageService.instance) {
      StorageService.instance = new StorageService();
    }
    return StorageService.instance;
  }


  /**
   * Ouvre la base de données IndexedDB
   */
  private async openDatabase(): Promise<IDBDatabase> {
    // Utiliser la fonction centralisée openDatabase
    const { openDatabase } = await import('../database-config');
    return openDatabase();
  }

  /**
   * Stocke des credentials
   */
  async storeCredentials(credentials: CredentialData): Promise<void> {
    try {
      const db = await this.openDatabase();
      const transaction = db.transaction([this.storeName], 'readwrite');
      const store = transaction.objectStore(this.storeName);

      await new Promise<void>((resolve, reject) => {
        const request = store.put(credentials, 'current');
        request.onsuccess = () => resolve();
        request.onerror = () => reject(request.error);
      });

      secureLogger.info('Credentials stored successfully', {
        component: 'StorageService',
        operation: 'storeCredentials'
      });
    } catch (error) {
      secureLogger.error('Failed to store credentials', error as Error, {
        component: 'StorageService',
        operation: 'storeCredentials'
      });
      throw error;
    }
  }

  /**
   * Récupère des credentials
   */
  async getCredentials(): Promise<CredentialData | null> {
    try {
      const db = await this.openDatabase();
      const transaction = db.transaction([this.storeName], 'readonly');
      const store = transaction.objectStore(this.storeName);

      return new Promise<CredentialData | null>((resolve, reject) => {
        const request = store.get('current');
        request.onsuccess = () => {
          const result = request.result;
          if (result) {
            secureLogger.info('Credentials retrieved successfully', {
              component: 'StorageService',
              operation: 'getCredentials'
            });
            resolve(result);
          } else {
            secureLogger.info('No credentials found', {
              component: 'StorageService',
              operation: 'getCredentials'
            });
            resolve(null);
          }
        };
        request.onerror = () => reject(request.error);
      });
    } catch (error) {
      secureLogger.error('Failed to get credentials', error as Error, {
        component: 'StorageService',
        operation: 'getCredentials'
      });
      return null;
    }
  }

  /**
   * Vérifie si des credentials existent
   */
  async hasCredentials(): Promise<boolean> {
    try {
      const credentials = await this.getCredentials();
      return credentials?.spendKey !== undefined &&
             credentials.scanKey !== undefined;
    } catch (error) {
      secureLogger.error('Failed to check credentials existence', error as Error, {
        component: 'StorageService',
        operation: 'hasCredentials'
      });
      return false;
    }
  }

  /**
   * Supprime les credentials
   */
  async clearCredentials(): Promise<void> {
    try {
      const db = await this.openDatabase();
      const transaction = db.transaction([this.storeName], 'readwrite');
      const store = transaction.objectStore(this.storeName);

      await new Promise<void>((resolve, reject) => {
        const request = store.delete('current');
        request.onsuccess = () => resolve();
        request.onerror = () => reject(request.error);
      });

      secureLogger.info('Credentials cleared successfully', {
        component: 'StorageService',
        operation: 'clearCredentials'
      });
    } catch (error) {
      secureLogger.error('Failed to clear credentials', error as Error, {
        component: 'StorageService',
        operation: 'clearCredentials'
      });
      throw error;
    }
  }
}