@gudhub/core 1.2.4-beta.3 → 1.2.4-beta.32

package/GUDHUB/DataService/IndexedDB/IndexedDBChunkService.js

@@ -2,6 +2,7 @@ import { ChunkDataService } from "../ChunkDataService.js"; // removed "ChunkCach
 import { ChunkHttpService } from "../httpService/ChunkHttpService.js";
 import { objectAssignWithOverride } from "../utils.js";
 import { IndexedDBService } from "./IndexedDBService.js";
+import { ChunksStoreManager, MergedChunksStoreManager } from "./StoreManager/managers.js";
 
 
 //this should be global in project
@@ -17,15 +18,28 @@ import { IndexedDBService } from "./IndexedDBService.js";
 
 
 export class IndexedDBChunkService extends ChunkDataService {
-    constructor(req, conf) {
+    constructor(req, conf, gudhub) {
       super(req, conf);
   
       this.dataService = new ChunkHttpService(req);
 
+      // let indexDBService = new IndexedDBService(conf);
 
-      let indexDBService = new IndexedDBService(conf);
+      this.requestCache = new Map; // id -> promise ///TODO seems irrelevant to class IndexedDBManager (could be renamed to Facade already)
 
-      objectAssignWithOverride(this, indexDBService);
+
+      this.gudhub = gudhub;
+
+
+      // this.storeManager = new ChunksStoreManager;
+      this.storeManager = new MergedChunksStoreManager;
+
+
+      // this.storeManager = new ChunksStoreManager;
+
+
+      // objectAssignWithOverride(this, indexDBService);
+      // objectAssignWithOverride(this, new ChunksStoreManager);
     }
 
     //TODO use IndexedDBFacade here
@@ -43,60 +57,302 @@ export class IndexedDBChunkService extends ChunkDataService {
       }
     }
 
+    async getCachedMergedChunk(id, chunkHashesList) {
+      try {
+        let cachedData = await this.storeManager.get(id);
+
+        return cachedData.mergedData;
+      } catch (error) {
+        // let newHashes = chunkHashesList.filter(c => !cachedData.hashes.includes(c));
+
+
+        const requests = chunkHashesList.map(hash => this.dataService.getChunk(id, hash));
+    
+        const newChunks = await Promise.all(requests);
+
+
+        let mergedData = await this.gudhub.util.mergeChunks(newChunks);
+
+        this.putMergedChunks(id, {hashes: chunkHashesList, mergedData: {items_list: mergedData}});
+
+        return {items_list: mergedData};
+      }
+    }
+
+    isWithCache() {
+      return true;
+    }
+
+
+    async getMergedChunkForApp(id) {
+      // here request api and get chunks list
+
+      //then perform all required checks for cached chunk and hashes and new hashes
+    }
+
+    //here // TODO replace this with getMergedChunkForApp in future
+    async getMergedChunkForIDList(id, chunkHashesList) {
+
+
+      //TODO promise cache
+
+      // TODO also try catch maybe
+
+
+      try {
+
+        
+        let isCachedValid = true;
+
+        let cachedData = await this.storeManager.get(id);
+
+
+        try {
+
+          if (chunkHashesList.length < cachedData.hashes.length) throw new Error;
+
+          for (let hash of cachedData.hashes) {
+            if (
+              chunkHashesList.indexOf(hash) != cachedData.hashes.indexOf(hash)
+            ) isCachedValid = false;
+          }
+        } catch (error) {
+          isCachedValid = false;
+        }
+
 
 
 
-    async putChunk(id, data) {
-      try {        
-        const db = await this.openDatabase();
 
-        const transaction = db.transaction(this.store, "readwrite");
-        const store = transaction.objectStore(this.store);
+        if (
+          !isCachedValid
+        ) {
+          // todo reload all data
+        }
 
-        store.put(data, id);
+
+
+        let newChunkHashes = [];
+        let newChunks = [];
+
+
+
+        if (
+          chunkHashesList.length > cachedData.hashes.length
+        ) {
+          newChunkHashes = chunkHashesList.slice(cachedData.hashes.length);
+        }
+
+        if (
+          !isCachedValid
+        ) {
+          newChunkHashes = chunkHashesList;
+        }
+
+        if (
+          newChunkHashes.length > 0
+        ) {
+          const requests = newChunkHashes.map(hash => this.dataService.getChunk(id, hash));
+      
+          newChunks = await Promise.all(requests);
+        }
+
+        let mergedData;
+        if (
+          !isCachedValid
+        ) {
+          mergedData = await this.gudhub.util.mergeChunks([
+            // cachedData.mergedData,
+            ...newChunks,
+          ]);
+        }
+
+        if (
+          isCachedValid
+        ) {
+          mergedData = await this.gudhub.util.mergeChunks([
+            cachedData.mergedData,
+            ...newChunks,
+          ]);
+        }
+
+
+        if (
+          newChunkHashes.length > 0
+        ) {
+          this.putMergedChunks(id, {hashes: chunkHashesList, mergedData: {items_list: mergedData}});
+        }
+
+        return {items_list: mergedData};
       } catch (error) {
+        // let newHashes = chunkHashesList.filter(c => !cachedData.hashes.includes(c));
+
+
+        const requests = chunkHashesList.map(hash => this.dataService.getChunk(id, hash));
+    
+        const newChunks = await Promise.all(requests);
+
 
+        let mergedData = await this.gudhub.util.mergeChunks(newChunks);
+
+        this.putMergedChunks(id, {hashes: chunkHashesList, mergedData: {items_list: mergedData}});
+
+        return {items_list: mergedData};
       }
     }
 
 
+
+    // async function fetchAndMergeArrays(urls) {
+    //   try {
+    //     // Create an array of fetch promises
+    //     const requests = urls.map(url => fetch(url).then(response => response.json()));
+    
+    //     // Wait for all requests to complete
+    //     const results = await Promise.all(requests);
+    
+    //     // Merge all arrays
+    //     const mergedArray = results.flat(); // or use reduce: results.reduce((acc, arr) => acc.concat(arr), []);
+    
+    //     return mergedArray;
+    //   } catch (error) {
+    //     console.error('Error fetching data:', error);
+    //     throw error;
+    //   }
+    // }
+    
+    // // Example usage:
+    // const urls = ['https://api.example.com/data1', 'https://api.example.com/data2'];
+    // fetchAndMergeArrays(urls)
+    //   .then(mergedArray => console.log(mergedArray))
+    //   .catch(error => console.error('Error:', error));
+    
+
+    //todo also optimize chunks transactions etc
+
+
+
+    async putMergedChunks(id, data) {
+      return this.storeManager.put(id, data);
+    }
+
+
+    // async getMergedChunks(id, data) {
+    //   return this.storeManager.get(id, data);
+    // }
+
+
+    async putChunk(id, data) {
+      return this.storeManager.putChunk(id, data);
+
+      // try {        
+      //   const db = await this.openDatabase(); //here
+
+      //   const transaction = db.transaction(this.store, "readwrite");
+      //   const store = transaction.objectStore(this.store);
+
+      //   store.put(data, id);
+      // } catch (error) {
+
+      // }
+    }
+
+
+    // async getApp(id) {
+    //   if (this.requestCache.has(id)) return this.requestCache.get(id);
+
+    //   let self = this;
+
+    //   let dataServiceRequest = this.dataService.getApp(id);
+
+    //   let pr = new Promise(async (resolve, reject) => {
+    //     try {
+    //       const db = await self.openDatabase();
+    //       const transaction = db.transaction(self.store, "readonly");
+    //       const store = transaction.objectStore(self.store);
+        
+    //       const storeRequest = store.get(id);
+
+    //       storeRequest.onsuccess = (e) => {
+    
+    //         let cachedData = e.target.result;
+      
+    //         if (
+    //           !cachedData
+    //         ) {
+    //           dataServiceRequest.then(resolve, reject);
+    //           dataServiceRequest.then(data => self.putApp(id, data));
+    //         }
+      
+    //         if (
+    //           cachedData
+    //         ) {
+    //           resolve(cachedData);
+
+    //           dataServiceRequest.then(async (data) => {
+    //             // self.gudhub.processAppUpd(data, cachedData);//
+    //             await self.putApp(id, data);
+    //             self.gudhub.triggerAppUpdate(id, prevVersion, newVersion);
+    //           });
+    //         }
+    //       };
+      
+    //       storeRequest.onerror = () => {
+    //         dataServiceRequest.then(resolve, reject);
+    //         dataServiceRequest.then(data => self.putApp(id, data));
+    //       }
+    //     } catch (error) {
+    //       dataServiceRequest.then(resolve, reject);
+    //       dataServiceRequest.then(data => self.putApp(id, data));
+    //     }
+    //   });
+
+    //   self.requestCache.set(id, pr);
+    
+    //   return pr;
+    // }
+
+
     async getChunk(app_id, id) {
       if (this.requestCache.has(id)) return this.requestCache.get(id);
 
       try {
-        let self = this;
 
-        let pr = new Promise(async (resolve, reject) => {
-          try {
-            const db = await self.openDatabase();
-            const transaction = db.transaction(self.store, "readonly");
-            const store = transaction.objectStore(self.store);
+        let pr = this.storeManager.getChunk(id);
+
+        // let self = this;
+
+        // let pr = new Promise(async (resolve, reject) => {
+        //   try {
+        //     const db = await self.openDatabase();
+        //     const transaction = db.transaction(self.store, "readonly");
+        //     const store = transaction.objectStore(self.store);
           
-            const storeRequest = store.get(id);
+        //     const storeRequest = store.get(id);
 
-            storeRequest.onsuccess = (e) => {
+        //     storeRequest.onsuccess = (e) => {
       
-              let cachedData = e.target.result;
+        //       let cachedData = e.target.result;
         
-              if (
-                !cachedData
-              ) {
-                reject();
-              }
+        //       if (
+        //         !cachedData
+        //       ) {
+        //         reject();
+        //       }
         
-              if (
-                cachedData
-              ) {
+        //       if (
+        //         cachedData
+        //       ) {
   
-                resolve(cachedData);
-              }
-            };
+        //         resolve(cachedData);
+        //       }
+        //     };
         
-            storeRequest.onerror = reject
-          } catch (error) {
-            reject();
-          }
-        });
+        //     storeRequest.onerror = reject
+        //   } catch (error) {
+        //     reject();
+        //   }
+        // });
 
         self.requestCache.set(id, pr);
 
@@ -112,21 +368,22 @@ export class IndexedDBChunkService extends ChunkDataService {
         let res = await reqPrms;
 
         this.putChunk(id, res);
+        // putPrms.then(() => self.gudhub.triggerAppUpdate(id));
   
         return reqPrms;
       }
     }
 
-    async openDatabase() {
-      return new Promise((resolve, reject) => {
-        const request = indexedDB.open(this.dbName, this.dbVersion);
-
-        request.onsuccess = event => {
-          resolve(event.target.result);
-        };
-        request.onerror = event => {
-          reject(event.target.error);
-        };
-      });
-    }
+    // async openDatabase() {
+    //   return new Promise((resolve, reject) => {
+    //     const request = indexedDB.open(this.dbName, this.dbVersion);
+
+    //     request.onsuccess = event => {
+    //       resolve(event.target.result);
+    //     };
+    //     request.onerror = event => {
+    //       reject(event.target.error);
+    //     };
+    //   });
+    // }
 }