@gudhub/core 1.2.4-beta.26 → 1.2.4-beta.28

package/GUDHUB/DataService/AppDataService.js

@@ -24,12 +24,35 @@ export class AppDataService extends DataService {
     async processRequestedApp(id, sentData) {
 
 
+        // let 
+
+
+        // let chunksHashesToLoad = sentData.chunks;
+
+        // let chunks = [];
+
+
+        // if (
+        //     this.chunkDataService.isWithCache()
+        // ) {
+
+        //     let cachedMergedChunkData = this.chunkDataService.getCached(id);
+
+        // }
+
+
         
-        
+        // all implementations are without cache for now
         if (
             !this.isWithCache()
         ) {
 
+
+            // let resultedMergedChunks = this.chunkDataService.getMergedChunk(id, sentData.chunks);
+
+
+            ///TODO here chunks could be with cache too
+
 //   async getChunks(app_id, chunk_ids) {
 //     let chunks = [];
 //     if(chunk_ids){
@@ -78,6 +101,10 @@ export class AppDataService extends DataService {
 
 
 
+        throw new Error;
+
+
+
 
 
 
@@ -87,6 +114,17 @@ export class AppDataService extends DataService {
             let cachedApp = await this.getCached(id); // this should be merged chunk + app from db
 
 
+            // if (
+            //     this.chunkDataService.isWithCache()
+            // ) {
+            //     let cachedMergedChunk = this.chunkDataService.getCached();
+            // }
+
+
+            // let res = await this.chunkDataService.getMergedChunkForIDList(id, sentData.chunks);
+
+
+
             // let cachedMergedChunk = await this.chunkDataService.getCachedMergedChunk(id, cachedApp.chunks);
 
             if (

package/GUDHUB/DataService/ChunkDataService.js

@@ -4,7 +4,12 @@ export class ChunkDataService extends DataService {
     //interface for indexeddb and http services
 
 
+    //here
     getMergedChunkForIDList(idList) {
         
     }
+
+    isWithCache() {
+        return false;
+    }
 }

package/GUDHUB/DataService/IndexedDB/IndexedDBAppService.js

@@ -177,6 +177,9 @@ export class IndexedDBAppServiceForWorker extends AppDataService {
 
       this.chunkDataService = new IndexedDBChunkService(req, chunksMergeConf, gudhub);
 
+      // let res = await this.chunkDataService.getMergedChunkForIDList(id, sentData.chunks);
+
+
 
 
       //TODO objectAssignWithOverride here too?
@@ -220,7 +223,7 @@ export class IndexedDBAppServiceForWorker extends AppDataService {
 
 
     isWithCache() {
-      return true;
+      return false;
     }
 
     // getApp(id) {
@@ -339,7 +342,7 @@ export class IndexedDBAppServiceForWorker extends AppDataService {
       // let dataServiceRequest = this.dataService.getAppWithoutProcessing(id);
       let data = await this.dataService.getAppWithoutProcessing(id);
       
-      await self.putApp(id, data);
+      // await self.putApp(id, data);
 
       let processedData = await self.processRequestedApp(id, data);//here нужно пересмотреть
 
@@ -571,6 +574,7 @@ export class IndexedDBAppService extends AppDataService {
 
 
       // todo check this for new code
+      // todo outdated code, to remove
       if (
         e.data.type == 'processData'
       ) {
@@ -640,7 +644,7 @@ export class IndexedDBAppService extends AppDataService {
 
 
   isWithCache() {
-    return true;
+    return false; //doesnt use indexeddb
   }
 
   async getApp(id) {//TODO -> get?
@@ -654,7 +658,7 @@ export class IndexedDBAppService extends AppDataService {
 
 
     if (
-      hasId
+      false
     ) {
 
       // let promiseObject = Promise.

package/GUDHUB/DataService/IndexedDB/IndexedDBChunkService.js

@@ -79,6 +79,18 @@ export class IndexedDBChunkService extends ChunkDataService {
       }
     }
 
+    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) {
 
 
@@ -88,30 +100,88 @@ export class IndexedDBChunkService extends ChunkDataService {
 
 
       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;
+        }
+
+
+
+
+
         if (
-          chunkHashesList.every(h1 => cachedData.hashes.includes(h1))
+          !isCachedValid
         ) {
-          return cachedData.mergedData;
+          // todo reload all data
         }
 
-          let newHashes = chunkHashesList.filter(c => !cachedData.hashes.includes(c));
 
 
-          const requests = newHashes.map(hash => this.dataService.getChunk(id, hash));
+        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));
       
-          const newChunks = await Promise.all(requests);
+          newChunks = await Promise.all(requests);
+        }
 
+        let mergedData;
+        if (
+          !isCachedValid
+        ) {
+          mergedData = await this.gudhub.util.mergeChunks([
+            // cachedData.mergedData,
+            ...newChunks,
+          ]);
+        }
 
-          let mergedData = await this.gudhub.util.mergeChunks([
+        if (
+          isCachedValid
+        ) {
+          mergedData = await this.gudhub.util.mergeChunks([
             cachedData.mergedData,
             ...newChunks,
           ]);
+        }
 
-        this.putMergedChunks(id, {hashes: chunkHashesList, mergedData: {items_list: mergedData}});
 
+        if (
+          newChunkHashes.length > 0
+        ) {
+          this.putMergedChunks(id, {hashes: chunkHashesList, mergedData: {items_list: mergedData}});
+        }
 
         return {items_list: mergedData};
       } catch (error) {

package/GUDHUB/DataService/IndexedDB/IndexedDBService.js

@@ -50,7 +50,9 @@ export class IndexedDBManager {
       // });
 
 
-      this.dbPrms = this.openDB();
+      // this.dbPrms = this.openDB();
+
+      this.db = null;
 
 
       // this.db = this.openDB();
@@ -135,11 +137,11 @@ export class IndexedDBManager {
       // TODO remove outdated stores before also
 
 
-      // if (this.db) return this.db;
+      if (this.db) return this.db;
 
       let resolver, rejecter;
 
-      this.dbPrms = new Promise((resolve, reject) => {
+      let dbPrms = new Promise((resolve, reject) => {
         resolver = resolve;
         rejecter = reject;
       });
@@ -169,7 +171,7 @@ export class IndexedDBManager {
         // };
   
         request.onsuccess = (event) => {
-          this.db = event.target.result;
+          self.db = event.target.result;
 
           // let version = this.db.version;
 
@@ -177,13 +179,15 @@ export class IndexedDBManager {
         };
   
         request.onerror = rejecter;
+
+        return dbPrms;
       // });
     }
   
     async executeOperation(storeName, operation) {
 
       //this get executed more than 1 time
-      await this.dbPrms;
+      let db = await this.openDB();
 
       // if (
       //   !this.db
@@ -195,12 +199,12 @@ export class IndexedDBManager {
       // await this.db;
 
 
-      let self = this;
+      // let self = this;
 
       // await this.db;
   
       return new Promise((resolve, reject) => {
-        const transaction = self.db.transaction(storeName, 'readwrite'); //TODO not all operations readwrite
+        const transaction = db.transaction(storeName, 'readwrite'); //TODO not all operations readwrite
         const store = transaction.objectStore(storeName);
   
         transaction.oncomplete = () => resolve();

package/GUDHUB/DataService/IndexedDB/appRequestWorker.js

@@ -54,6 +54,7 @@ self.onmessage = async function(e) {
     ) isMergedChunkUpdated = false;
 
 
+    //TODO here old chunks should be exactly with ids that came from app get request
     if (
       nextVersion.chunks.some(entry => !cachedChunksList.includes(entry))
     ) isMergedChunkUpdated = false;
@@ -148,6 +149,70 @@ self.onmessage = async function(e) {
     e.data.type === 'requestApp'
   ) {
 
+    // //todo cached could not exist !!!!!!!!!!!!!!!!!!!
+
+    // let cached = await appDataService.getCached(e.data.id); // merge ?
+
+
+    // let cachedChunksList = cached.chunks;
+
+
+    // let nextVersion = await appDataService.getAppWithoutProcessing(e.data.id);
+
+
+    // let isMergedChunkUpdated = true;
+
+
+    // if (
+    //   cachedChunksList.length != nextVersion.chunks.length
+    // ) isMergedChunkUpdated = false;
+
+
+    // //TODO here old chunks should be exactly with ids that came from app get request
+    // if (
+    //   nextVersion.chunks.some(entry => !cachedChunksList.includes(entry))
+    // ) isMergedChunkUpdated = false;
+
+
+    // if (
+    //   !isMergedChunkUpdated
+    // ) {
+
+    //   // TODO this is repetitive operation for getCached, maybe put all code in process or in getCached
+
+    //   let res = await chunkDataService.getCachedMergedChunk(e.data.id, cached.chunks);
+
+    //   // if (!res) res = [];
+
+
+    //   // // TODO check that res always exists
+
+
+    //   if (
+    //       res
+    //   ) {
+    //       cached.items_list = await gudhub.util.mergeChunks([
+    //           // cachedApp,
+    //           res,
+    //           cached,
+    //       ]);
+    //   } else {
+    //       // sentData.items_list = await this.gudhub.util.mergeChunks([
+    //       //     cachedApp,
+    //       //     sentData,
+    //       // ]);
+    //   }
+
+    //   // nextVersion = await appDataService.getAppWithSpecificChunksList(e.data.id, newChunksList); //todo check that here most recent always
+    //   nextVersion = await appDataService.getApp(e.data.id); //todo check that here most recent always
+
+
+    //   //TODO тут достаточно сравнить новые чанки+апп и закешированный апп, тогда будет сгенерирована вся инфа о новых данных
+
+
+    //   // return;
+    // }
+
     let data = await appDataService.getApp(e.data.id); //todo check process request method seems there i return cahced version not most recent data from server
 
 

package/GUDHUB/DataService/export.js

@@ -34,9 +34,9 @@ if (
 
 if (
     IS_BROWSER &&
-    cache_app_requests
+    cache_app_requests // todo here outdated approach
 ) {
-    AppDataService = IndexedDBAppService;
+    AppDataService = IndexedDBAppService; // here will be AppHttpService for browser too, check compatability. Checked. seems different code. IndexedDBAppService uses worker
     appDataServiceConf = appsConf;
 } else {
     AppDataService = AppHttpService;

package/GUDHUB/DataService/httpService/ChunkHttpService.js

@@ -30,6 +30,7 @@ export class ChunkHttpService extends ChunkDataService {
     }
 
 
+    //here
     getMergedChunkForIDList(id, chunkHashesList) {
       
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gudhub/core",
-  "version": "1.2.4-beta.26",
+  "version": "1.2.4-beta.28",
   "description": "",
   "main": "index.js",
   "scripts": {