4nk/ihm_client
5
0
Fork 0
Code Issues 6 Pull Requests Actions Packages Projects Releases Wiki Activity

Refacto to use database service methods

Browse Source
This commit is contained in:
omaroughriss 2025-11-27 16:34:14 +01:00
parent 19dcb2000e
commit 739f749619
1 changed files with 89 additions and 219 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

304
src/services/service.ts
View File

@ -194,26 +194,15 @@ export default class Services {
} }
public async getSecretForAddress(address: string): Promise<string | null> { public async getSecretForAddress(address: string): Promise<string | null> {
const db = await Database.getInstance(); return await this.db.getSharedSecret(address);
return await db.getObject('shared_secrets', address);
} }
public async getAllSecrets(): Promise<SecretsStore> { public async getAllSecrets(): Promise<SecretsStore> {
const db = await Database.getInstance(); return await this.db.getAllSecrets();
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;
} }
public async getAllDiffs(): Promise<Record<string, UserDiff>> { public async getAllDiffs(): Promise<Record<string, UserDiff>> {
const db = await Database.getInstance(); return await this.db.getAllDiffs();
return await db.dumpStore('diffs');
} }
/** /**
@ -236,10 +225,7 @@ export default class Services {
} }
public async getDiffByValue(value: string): Promise<UserDiff | null> { public async getDiffByValue(value: string): Promise<UserDiff | null> {
const db = await Database.getInstance(); return await this.db.getDiff(value);
const store = 'diffs';
const res = await db.getObject(store, value);
return res;
} }
private async getTokensFromFaucet(): Promise<void> { private async getTokensFromFaucet(): Promise<void> {
@ -843,12 +829,7 @@ export default class Services {
this.sdkClient.reset_device(); this.sdkClient.reset_device();
// Clear all stores // Clear all stores
const db = await Database.getInstance(); await this.db.clearMultipleStores(['wallet', 'shared_secrets', 'unconfirmed_secrets', 'processes', 'diffs']);
await db.clearStore('wallet');
await db.clearStore('shared_secrets');
await db.clearStore('unconfirmed_secrets');
await db.clearStore('processes');
await db.clearStore('diffs');
console.warn('[Services:resetDevice] ✅ Réinitialisation terminée.'); console.warn('[Services:resetDevice] ✅ Réinitialisation terminée.');
} }
@ -1052,39 +1033,19 @@ export default class Services {
private async handleSecrets(secrets: any) { private async handleSecrets(secrets: any) {
const { unconfirmed_secrets, shared_secrets } = secrets; const { unconfirmed_secrets, shared_secrets } = secrets;
const db = await Database.getInstance();
// Sauvegarder les secrets non confirmés const unconfirmedList = unconfirmed_secrets && unconfirmed_secrets.length > 0 ? unconfirmed_secrets : [];
if (unconfirmed_secrets && unconfirmed_secrets.length > 0) { const sharedList = shared_secrets && Object.keys(shared_secrets).length > 0
console.log(`[Services:handleSecrets] 💾 Sauvegarde de ${unconfirmed_secrets.length} secret(s) non confirmé(s)`); ? Object.entries(shared_secrets).map(([key, value]) => ({ key, value }))
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);
}
}
}
// Sauvegarder les secrets partagés (confirmés) if (unconfirmedList.length > 0 || sharedList.length > 0) {
if (shared_secrets && Object.keys(shared_secrets).length > 0) { console.log(`[Services:handleSecrets] 💾 Sauvegarde batch: ${unconfirmedList.length} secret(s) non confirmé(s) + ${sharedList.length} secret(s) partagé(s)`);
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 { try {
await db.addObject({ await this.db.saveSecretsBatch(unconfirmedList, sharedList);
storeName: 'shared_secrets', console.log('[Services:handleSecrets] ✅ Secrets sauvegardés en batch.');
object: entry.value,
key: entry.key,
});
console.log(`[Services:handleSecrets] ✅ Secret partagé pour ${entry.key} sauvegardé.`);
} catch (e) { } catch (e) {
console.error(`[Services:handleSecrets] 💥 Échec de l'ajout du secret partagé pour ${entry.key}:`, 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> { async saveDeviceInDatabase(device: Device): Promise<void> {
const db = await Database.getInstance();
const walletStore = 'wallet';
try { try {
console.log("[Services:saveDeviceInDatabase] 💾 Sauvegarde de l'appareil en BDD...", { console.log("[Services:saveDeviceInDatabase] 💾 Sauvegarde de l'appareil en BDD...", {
pairing_process_commitment: device.pairing_process_commitment, pairing_process_commitment: device.pairing_process_commitment,
paired_member: device.paired_member, paired_member: device.paired_member,
}); });
const prevDevice = await this.getDeviceFromDatabase(); await this.db.saveDevice(device);
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,
});
console.log('[Services:saveDeviceInDatabase] ✅ Appareil sauvegardé avec succès'); 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) { } catch (e) {
console.error('[Services:saveDeviceInDatabase] 💥 Erreur lors de la sauvegarde:', e); console.error('[Services:saveDeviceInDatabase] 💥 Erreur lors de la sauvegarde:', e);
} }
} }
async getDeviceFromDatabase(): Promise<Device | null> { async getDeviceFromDatabase(): Promise<Device | null> {
const db = await Database.getInstance();
const walletStore = 'wallet';
try { try {
const dbRes = await db.getObject(walletStore, '1'); return await this.db.getDevice();
if (dbRes) {
return dbRes['device'];
} else {
return null;
}
} catch (e) { } catch (e) {
throw new Error(`[Services:getDeviceFromDatabase] 💥 Échec: ${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>) { public async batchSaveProcessesToDb(processes: Record<string, Process>) {
if (Object.keys(processes).length === 0) { if (Object.keys(processes).length === 0) {
return; return;
} }
console.log(`[Services:batchSaveProcessesToDb] 💾 Sauvegarde de ${Object.keys(processes).length} processus en BDD...`); console.log(`[Services:batchSaveProcessesToDb] 💾 Sauvegarde de ${Object.keys(processes).length} processus en BDD...`);
const db = await Database.getInstance();
const storeName = 'processes';
try { 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 }; this.processesCache = { ...this.processesCache, ...processes };
} catch (e) { } catch (e) {
console.error('[Services:batchSaveProcessesToDb] 💥 Échec:', e); console.error('[Services:batchSaveProcessesToDb] 💥 Échec:', e);
throw e;
} }
} }
public async saveProcessToDb(processId: string, process: Process) { public async saveProcessToDb(processId: string, process: Process) {
const db = await Database.getInstance();
const storeName = 'processes';
try { try {
await db.addObject({ await this.db.saveProcess(processId, process);
storeName,
object: process,
key: processId,
});
// Update the process in the cache // Update the process in the cache
this.processesCache[processId] = process; this.processesCache[processId] = process;
} catch (e) { } catch (e) {
@ -1629,27 +1541,81 @@ export default class Services {
} }
public async saveBlobToDb(hash: string, data: Blob) { public async saveBlobToDb(hash: string, data: Blob) {
const db = await Database.getInstance();
try { try {
await db.addObject({ await this.db.saveBlob(hash, data);
storeName: 'data',
object: data,
key: hash,
});
} catch (e) { } catch (e) {
console.error(`[Services:saveBlobToDb] 💥 Échec de la sauvegarde du blob ${hash}: ${e}`); console.error(`[Services:saveBlobToDb] 💥 Échec de la sauvegarde du blob ${hash}: ${e}`);
} }
} }
public async getBlobFromDb(hash: string): Promise<Blob | null> { public async getBlobFromDb(hash: string): Promise<Blob | null> {
const db = await Database.getInstance();
try { try {
return await db.getObject('data', hash); return await this.db.getBlob(hash);
} catch (e) { } catch (e) {
return null; 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) { public async saveDataToStorage(storages: string[], hash: string, data: Blob, ttl: number | null) {
try { try {
await storeData(storages, hash, data, ttl); await storeData(storages, hash, data, ttl);
@ -1665,113 +1631,23 @@ export default class Services {
} }
public async getDiffByValueFromDb(hash: string): Promise<UserDiff | null> { public async getDiffByValueFromDb(hash: string): Promise<UserDiff | null> {
const db = await Database.getInstance(); return await this.db.getDiff(hash);
const diff = await db.getObject('diffs', hash);
return diff;
} }
public async saveDiffsToDb(diffs: UserDiff[]) { public async saveDiffsToDb(diffs: UserDiff[]) {
const db = await Database.getInstance();
try { try {
for (const diff of diffs) { await this.db.saveDiffs(diffs);
await db.addObject({
storeName: 'diffs',
object: diff,
key: null,
});
}
} catch (e) { } catch (e) {
throw new Error(`[Services:saveDiffsToDb] 💥 Échec: ${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) { public async restoreSecretsFromBackUp(secretsStore: SecretsStore) {
console.log('[Services:restoreSecretsFromBackUp] 💾 Restauration des secrets depuis un backup...'); console.log('[Services:restoreSecretsFromBackUp] 💾 Restauration des secrets depuis un backup...');
const db = await Database.getInstance();
for (const secret of secretsStore.unconfirmed_secrets) { const sharedList = Object.entries(secretsStore.shared_secrets).map(([key, value]) => ({ key, value }));
await db.addObject({ await this.db.saveSecretsBatch(secretsStore.unconfirmed_secrets, sharedList);
storeName: 'unconfirmed_secrets', console.log('[Services:restoreSecretsFromBackUp] ✅ Secrets restaurés en batch.');
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,
});
}
// Now we can transfer them to memory // Now we can transfer them to memory
await this.restoreSecretsFromDB(); await this.restoreSecretsFromDB();
@ -1779,16 +1655,10 @@ export default class Services {
public async restoreSecretsFromDB() { public async restoreSecretsFromDB() {
console.log('[Services:restoreSecretsFromDB] 🔄 Restauration des secrets depuis la BDD vers la mémoire SDK...'); console.log('[Services:restoreSecretsFromDB] 🔄 Restauration des secrets depuis la BDD vers la mémoire SDK...');
const db = await Database.getInstance();
try { try {
const sharedSecrets: Record<string, string> = await db.dumpStore('shared_secrets'); const secretsStore = await this.db.getAllSecrets();
const unconfirmedSecrets = await db.dumpStore('unconfirmed_secrets');
const secretsStore = {
shared_secrets: sharedSecrets,
unconfirmed_secrets: Object.values(unconfirmedSecrets),
};
this.sdkClient.set_shared_secrets(JSON.stringify(secretsStore)); 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) { } catch (e) {
throw e; throw e;
} }