Refacto to use database service methods

src/services/service.ts

@@ -194,26 +194,15 @@ export default class Services {
   }
 
   public async getSecretForAddress(address: string): Promise<string | null> {
-    const db = await Database.getInstance();
-    return await db.getObject('shared_secrets', address);
+    return await this.db.getSharedSecret(address);
   }
 
   public async getAllSecrets(): Promise<SecretsStore> {
-    const db = await Database.getInstance();
-    const sharedSecrets = await db.dumpStore('shared_secrets');
-    const unconfirmedSecrets = await db.dumpStore('unconfirmed_secrets'); // keys are numeric values
-
-    const secretsStore = {
-      shared_secrets: sharedSecrets,
-      unconfirmed_secrets: Object.values(unconfirmedSecrets),
-    };
-
-    return secretsStore;
+    return await this.db.getAllSecrets();
   }
 
   public async getAllDiffs(): Promise<Record<string, UserDiff>> {
-    const db = await Database.getInstance();
-    return await db.dumpStore('diffs');
+    return await this.db.getAllDiffs();
   }
 
   /**
@@ -236,10 +225,7 @@ export default class Services {
   }
 
   public async getDiffByValue(value: string): Promise<UserDiff | null> {
-    const db = await Database.getInstance();
-    const store = 'diffs';
-    const res = await db.getObject(store, value);
-    return res;
+    return await this.db.getDiff(value);
   }
 
   private async getTokensFromFaucet(): Promise<void> {
@@ -843,12 +829,7 @@ export default class Services {
     this.sdkClient.reset_device();
 
     // Clear all stores
-    const db = await Database.getInstance();
-    await db.clearStore('wallet');
-    await db.clearStore('shared_secrets');
-    await db.clearStore('unconfirmed_secrets');
-    await db.clearStore('processes');
-    await db.clearStore('diffs');
+    await this.db.clearMultipleStores(['wallet', 'shared_secrets', 'unconfirmed_secrets', 'processes', 'diffs']);
     console.warn('[Services:resetDevice] ✅ Réinitialisation terminée.');
   }
 
@@ -1052,39 +1033,19 @@ export default class Services {
 
   private async handleSecrets(secrets: any) {
     const { unconfirmed_secrets, shared_secrets } = secrets;
-    const db = await Database.getInstance();
 
-    // Sauvegarder les secrets non confirmés
-    if (unconfirmed_secrets && unconfirmed_secrets.length > 0) {
-      console.log(`[Services:handleSecrets] 💾 Sauvegarde de ${unconfirmed_secrets.length} secret(s) non confirmé(s)`);
-      for (const secret of unconfirmed_secrets) {
-        try {
-          await db.addObject({
-            storeName: 'unconfirmed_secrets',
-            object: secret,
-            key: null,
-          });
-        } catch (e) {
-          console.error("[Services:handleSecrets] 💥 Échec de sauvegarde d'un secret non confirmé:", e);
-        }
-      }
-    }
+    const unconfirmedList = unconfirmed_secrets && unconfirmed_secrets.length > 0 ? unconfirmed_secrets : [];
+    const sharedList = shared_secrets && Object.keys(shared_secrets).length > 0 
+      ? Object.entries(shared_secrets).map(([key, value]) => ({ key, value }))
+      : [];
 
-    // Sauvegarder les secrets partagés (confirmés)
-    if (shared_secrets && Object.keys(shared_secrets).length > 0) {
-      const entries = Object.entries(shared_secrets).map(([key, value]) => ({ key, value }));
-      console.log(`[Services:handleSecrets] 💾 Sauvegarde de ${entries.length} secret(s) partagé(s)`);
-      for (const entry of entries) {
-        try {
-          await db.addObject({
-            storeName: 'shared_secrets',
-            object: entry.value,
-            key: entry.key,
-          });
-          console.log(`[Services:handleSecrets] ✅ Secret partagé pour ${entry.key} sauvegardé.`);
-        } catch (e) {
-          console.error(`[Services:handleSecrets] 💥 Échec de l'ajout du secret partagé pour ${entry.key}:`, e);
-        }
+    if (unconfirmedList.length > 0 || sharedList.length > 0) {
+      console.log(`[Services:handleSecrets] 💾 Sauvegarde batch: ${unconfirmedList.length} secret(s) non confirmé(s) + ${sharedList.length} secret(s) partagé(s)`);
+      try {
+        await this.db.saveSecretsBatch(unconfirmedList, sharedList);
+        console.log('[Services:handleSecrets] ✅ Secrets sauvegardés en batch.');
+      } catch (e) {
+        console.error('[Services:handleSecrets] 💥 Échec de sauvegarde batch des secrets:', e);
       }
     }
   }
@@ -1390,49 +1351,22 @@ export default class Services {
   }
 
   async saveDeviceInDatabase(device: Device): Promise<void> {
-    const db = await Database.getInstance();
-    const walletStore = 'wallet';
     try {
       console.log("[Services:saveDeviceInDatabase] 💾 Sauvegarde de l'appareil en BDD...", {
         pairing_process_commitment: device.pairing_process_commitment,
         paired_member: device.paired_member,
       });
 
-      const prevDevice = await this.getDeviceFromDatabase();
-      if (prevDevice) {
-        // console.debug('[Services:saveDeviceInDatabase] ℹ️ Appareil précédent trouvé, suppression...');
-        await db.deleteObject(walletStore, '1');
-      }
-
-      await db.addObject({
-        storeName: walletStore,
-        object: { pre_id: '1', device },
-        key: null,
-      });
-
+      await this.db.saveDevice(device);
       console.log('[Services:saveDeviceInDatabase] ✅ Appareil sauvegardé avec succès');
-
-      // // Verify save
-      // const savedDevice = await this.getDeviceFromDatabase();
-      // console.log('[Services:saveDeviceInDatabase] 🔎 Vérification:', {
-      //   pairing_process_commitment: savedDevice?.pairing_process_commitment,
-      //   paired_member: savedDevice?.paired_member,
-      // });
     } catch (e) {
       console.error('[Services:saveDeviceInDatabase] 💥 Erreur lors de la sauvegarde:', e);
     }
   }
 
   async getDeviceFromDatabase(): Promise<Device | null> {
-    const db = await Database.getInstance();
-    const walletStore = 'wallet';
     try {
-      const dbRes = await db.getObject(walletStore, '1');
-      if (dbRes) {
-        return dbRes['device'];
-      } else {
-        return null;
-      }
+      return await this.db.getDevice();
     } catch (e) {
       throw new Error(`[Services:getDeviceFromDatabase] 💥 Échec: ${e}`);
     }
@@ -1583,44 +1517,22 @@ export default class Services {
     }
   }
 
-  private async removeProcess(processId: string): Promise<void> {
-    const db = await Database.getInstance();
-    const storeName = 'processes';
-
-    try {
-      console.log(`[Services:removeProcess] 🗑️ Suppression du processus ${processId}`);
-      await db.deleteObject(storeName, processId);
-    } catch (e) {
-      console.error(e);
-    }
-  }
-
   public async batchSaveProcessesToDb(processes: Record<string, Process>) {
     if (Object.keys(processes).length === 0) {
       return;
     }
     console.log(`[Services:batchSaveProcessesToDb] 💾 Sauvegarde de ${Object.keys(processes).length} processus en BDD...`);
-    const db = await Database.getInstance();
-    const storeName = 'processes';
     try {
-      await db.batchWriting({ storeName, objects: Object.entries(processes).map(([key, value]) => ({ key, object: value })) });
+      await this.db.saveProcessesBatch(processes);
       this.processesCache = { ...this.processesCache, ...processes };
     } catch (e) {
       console.error('[Services:batchSaveProcessesToDb] 💥 Échec:', e);
-      throw e;
     }
   }
 
   public async saveProcessToDb(processId: string, process: Process) {
-    const db = await Database.getInstance();
-    const storeName = 'processes';
     try {
-      await db.addObject({
-        storeName,
-        object: process,
-        key: processId,
-      });
-
+      await this.db.saveProcess(processId, process);
       // Update the process in the cache
       this.processesCache[processId] = process;
     } catch (e) {
@@ -1629,27 +1541,81 @@ export default class Services {
   }
 
   public async saveBlobToDb(hash: string, data: Blob) {
-    const db = await Database.getInstance();
     try {
-      await db.addObject({
-        storeName: 'data',
-        object: data,
-        key: hash,
-      });
+      await this.db.saveBlob(hash, data);
     } catch (e) {
       console.error(`[Services:saveBlobToDb] 💥 Échec de la sauvegarde du blob ${hash}: ${e}`);
     }
   }
 
   public async getBlobFromDb(hash: string): Promise<Blob | null> {
-    const db = await Database.getInstance();
     try {
-      return await db.getObject('data', hash);
+      return await this.db.getBlob(hash);
     } catch (e) {
       return null;
     }
   }
 
+  public async getProcess(processId: string): Promise<Process | null> {
+    // 1. Essayer le cache en mémoire
+    if (this.processesCache[processId]) {
+      return this.processesCache[processId];
+    }
+
+    // 2. Si non trouvé, essayer la BDD
+    try {
+      const process = await this.db.getProcess(processId);
+      if (process) {
+        this.processesCache[processId] = process; // Mettre en cache
+      }
+      return process;
+    } catch (e) {
+      console.error(`[Services:getProcess] 💥 Échec de la récupération du processus ${processId}: ${e}`);
+      return null;
+    }
+  }
+
+  public async getProcesses(): Promise<Record<string, Process>> {
+    // 1. Essayer le cache en mémoire
+    if (Object.keys(this.processesCache).length > 0) {
+      return this.processesCache;
+    }
+
+    // 2. Si non trouvé, charger depuis la BDD
+    try {
+      console.log('[Services:getProcesses] ℹ️ Cache de processus vide. Chargement depuis la BDD...');
+      this.processesCache = await this.db.getAllProcesses();
+      console.log(`[Services:getProcesses] ✅ ${Object.keys(this.processesCache).length} processus chargés en cache.`);
+      return this.processesCache;
+    } catch (e) {
+      console.error('[Services:getProcesses] 💥 Échec:', e);
+      return {};
+    }
+  }
+
+  public async restoreProcessesFromBackUp(processes: Record<string, Process>) {
+    console.log(`[Services:restoreProcessesFromBackUp] 💾 Restauration de ${Object.keys(processes).length} processus depuis un backup...`);
+    try {
+      await this.db.saveProcessesBatch(processes);
+    } catch (e) {
+      throw e;
+    }
+  }
+
+  // Restore processes cache from persistent storage
+  public async restoreProcessesFromDB() {
+    try {
+      const processes: Record<string, Process> = await this.db.getAllProcesses();
+      if (processes && Object.keys(processes).length != 0) {
+        console.log(`[Services:restoreProcessesFromDB] 🔄 Restauration de ${Object.keys(processes).length} processus depuis la BDD vers le cache...`);
+        this.processesCache = processes;
+        console.log('[Services:restoreProcessesFromDB] ✅ Processus restaurés.');
+      }
+    } catch (e) {
+      throw e;
+    }
+  }
+
   public async saveDataToStorage(storages: string[], hash: string, data: Blob, ttl: number | null) {
     try {
       await storeData(storages, hash, data, ttl);
@@ -1665,113 +1631,23 @@ export default class Services {
   }
 
   public async getDiffByValueFromDb(hash: string): Promise<UserDiff | null> {
-    const db = await Database.getInstance();
-    const diff = await db.getObject('diffs', hash);
-    return diff;
+    return await this.db.getDiff(hash);
   }
 
   public async saveDiffsToDb(diffs: UserDiff[]) {
-    const db = await Database.getInstance();
     try {
-      for (const diff of diffs) {
-        await db.addObject({
-          storeName: 'diffs',
-          object: diff,
-          key: null,
-        });
-      }
+      await this.db.saveDiffs(diffs);
     } catch (e) {
       throw new Error(`[Services:saveDiffsToDb] 💥 Échec: ${e}`);
     }
   }
 
-  public async getProcess(processId: string): Promise<Process | null> {
-    // 1. Essayer le cache en mémoire
-    if (this.processesCache[processId]) {
-      return this.processesCache[processId];
-    }
-
-    // 2. Si non trouvé, essayer la BDD
-    try {
-      const db = await Database.getInstance();
-      const process = await db.getObject('processes', processId);
-      if (process) {
-        this.processesCache[processId] = process; // Mettre en cache
-      }
-      return process;
-    } catch (e) {
-      console.error(`[Services:getProcess] 💥 Échec de récupération du processus ${processId}:`, e);
-      return null;
-    }
-  }
-
-  public async getProcesses(): Promise<Record<string, Process>> {
-    // 1. Essayer le cache en mémoire
-    if (Object.keys(this.processesCache).length > 0) {
-      return this.processesCache;
-    }
-
-    // 2. Si non trouvé, charger depuis la BDD
-    try {
-      console.log('[Services:getProcesses] ℹ️ Cache de processus vide. Chargement depuis la BDD...');
-      const db = await Database.getInstance();
-      this.processesCache = await db.dumpStore('processes');
-      console.log(`[Services:getProcesses] ✅ ${Object.keys(this.processesCache).length} processus chargés en cache.`);
-      return this.processesCache;
-    } catch (e) {
-      console.error('[Services:getProcesses] 💥 Échec du chargement des processus:', e);
-      throw e;
-    }
-  }
-
-  public async restoreProcessesFromBackUp(processes: Record<string, Process>) {
-    console.log(`[Services:restoreProcessesFromBackUp] 💾 Restauration de ${Object.keys(processes).length} processus depuis un backup...`);
-    const db = await Database.getInstance();
-    const storeName = 'processes';
-    try {
-      await db.batchWriting({ storeName, objects: Object.entries(processes).map(([key, value]) => ({ key, object: value })) });
-    } catch (e) {
-      throw e;
-    }
-
-    await this.restoreProcessesFromDB();
-  }
-
-  // Restore processes cache from persistent storage
-  public async restoreProcessesFromDB() {
-    const db = await Database.getInstance();
-    try {
-      const processes: Record<string, Process> = await db.dumpStore('processes');
-      if (processes && Object.keys(processes).length != 0) {
-        console.log(`[Services:restoreProcessesFromDB] 🔄 Restauration de ${Object.keys(processes).length} processus depuis la BDD vers le cache...`);
-        this.processesCache = processes;
-      } else {
-        console.log('[Services:restoreProcessesFromDB] ℹ️ Aucun processus à restaurer.');
-      }
-    } catch (e) {
-      throw e;
-    }
-  }
-
   public async restoreSecretsFromBackUp(secretsStore: SecretsStore) {
     console.log('[Services:restoreSecretsFromBackUp] 💾 Restauration des secrets depuis un backup...');
-    const db = await Database.getInstance();
 
-    for (const secret of secretsStore.unconfirmed_secrets) {
-      await db.addObject({
-        storeName: 'unconfirmed_secrets',
-        object: secret,
-        key: null,
-      });
-    }
-    const entries = Object.entries(secretsStore.shared_secrets).map(([key, value]) => ({ key, value }));
-    for (const entry of entries) {
-      await db.addObject({
-        storeName: 'shared_secrets',
-        object: entry.value,
-        key: entry.key,
-      });
-    }
+    const sharedList = Object.entries(secretsStore.shared_secrets).map(([key, value]) => ({ key, value }));
+    await this.db.saveSecretsBatch(secretsStore.unconfirmed_secrets, sharedList);
+    console.log('[Services:restoreSecretsFromBackUp] ✅ Secrets restaurés en batch.');
 
     // Now we can transfer them to memory
     await this.restoreSecretsFromDB();
@@ -1779,16 +1655,10 @@ export default class Services {
 
   public async restoreSecretsFromDB() {
     console.log('[Services:restoreSecretsFromDB] 🔄 Restauration des secrets depuis la BDD vers la mémoire SDK...');
-    const db = await Database.getInstance();
     try {
-      const sharedSecrets: Record<string, string> = await db.dumpStore('shared_secrets');
-      const unconfirmedSecrets = await db.dumpStore('unconfirmed_secrets');
-      const secretsStore = {
-        shared_secrets: sharedSecrets,
-        unconfirmed_secrets: Object.values(unconfirmedSecrets),
-      };
+      const secretsStore = await this.db.getAllSecrets();
       this.sdkClient.set_shared_secrets(JSON.stringify(secretsStore));
-      console.log(`[Services:restoreSecretsFromDB] ✅ ${Object.keys(sharedSecrets).length} secrets partagés restaurés.`);
+      console.log(`[Services:restoreSecretsFromDB] ✅ ${Object.keys(secretsStore.shared_secrets).length} secrets partagés restaurés.`);
     } catch (e) {
       throw e;
     }