@gudhub/core 1.2.4-beta.6 → 1.2.4-beta.9

package/GUDHUB/AppProcessor/AppProcessor.js

@@ -6,7 +6,7 @@ export class AppProcessor {
     pipeService,
     req,
     websocket,
-    chunksManager,
+    // chunksManager,
     util,
     activateSW,
     dataService,
@@ -17,10 +17,15 @@ export class AppProcessor {
     this.ws = websocket;
     this.applistReceived = false;
     this.activateSW = activateSW; // we use this flag to check if applist was received. The problem is that if you receive an app it also goes to app_list as a result you have the app_list with one app.
-    this.chunksManager = chunksManager;
+    // this.chunksManager = chunksManager;
     this.util = util;
     this.appListeners();
     this.dataService = dataService;
+
+    this.appRequestCache = new Map;
+
+
+    // this.dataServiceRequestedIdSet = new Set;
   }
 
   async createNewAppApi(app) {
@@ -255,27 +260,45 @@ export class AppProcessor {
     let app = this.getAppFromStorage(app_id);
     if (app) return app;
 
-    let receivedApp = await this.dataService.getApp(app_id);
-    if (!receivedApp) return;
-
-    //!!! temporary check !!!! if app has chanks property then we start getting it
-    if (
-      receivedApp.chunks &&
-      receivedApp.chunks.length
-    ) {
-      let chunks = await this.chunksManager.getChunks(app_id, receivedApp.chunks);
-      receivedApp.items_list = this.util.mergeChunks([
-        ...chunks,
-        receivedApp,
-      ]);
-    }
+    if (this.appRequestCache.has(app_id)) return this.appRequestCache.get(app_id);
+
+    let self = this;
+
+    let pr = new Promise(async (resolve, reject) => {
+      try {
+        let receivedApp = await self.dataService.getApp(app_id);
+        if (!receivedApp) reject();
+    
+        //!!! temporary check !!!! if app has chanks property then we start getting it
+        // if (
+        //   receivedApp.chunks &&
+        //   receivedApp.chunks.length
+        // ) {
+        //   // here should be checked is merge required
 
-    this.saveAppInStorage(receivedApp);
-    this.ws.addSubscription(app_id);
 
-    // This code for trash must be changed
-    // return trash ? app : {...app, items_list: app.items_list.filter(item => !item.trash)};
-    return receivedApp;
+        //   let chunks = await self.chunksManager.getChunks(app_id, receivedApp.chunks);
+        //   receivedApp.items_list = self.util.mergeChunks([
+        //     ...chunks,
+        //     receivedApp,
+        //   ]);
+        // }
+
+
+        // This code for trash must be changed
+        // return trash ? app : {...app, items_list: app.items_list.filter(item => !item.trash)};
+        resolve(receivedApp);
+    
+        self.saveAppInStorage(receivedApp);
+        self.ws.addSubscription(app_id);
+      } catch (error) {
+        reject();
+      }
+    });
+
+    self.appRequestCache.set(app_id, pr);
+  
+    return pr;
   }
 
   async updateApp(app) {
@@ -319,7 +342,7 @@ export class AppProcessor {
     }
   }
 
-  handleAppChange(v1, v2) {
+  async handleAppChange(id, prevVersion, nextVersion) {
     // generate required events etc, do job
   }
 
@@ -461,7 +484,7 @@ export class AppProcessor {
               }
             );
           }
-          event.data.payload.items_list = this.util.mergeChunks([app, event.data.payload])
+          event.data.payload.items_list = await this.util.mergeChunks([app, event.data.payload])
           this.saveAppInStorage(event.data.payload);
         }
         // if (event.data.type === "refresh appList") {

package/GUDHUB/ChunksManager/ChunksManager.js

@@ -1,68 +1,68 @@
-import { ChunkAPI } from "../api/ChunkApi.js";
+// import { ChunkAPI } from "../api/ChunkApi.js";
 
 
-export class ChunksManager {
-  constructor(
-    storage,
-    pipeService,
-    req,
-    util,
-    dataService,
-  ) {
-    this.storage = storage;
-    this.pipeService = pipeService;
-    this.req = req;
-    this.util = util;
-    this.dataService = dataService;
-    this.chunkApi = new ChunkAPI(req);
-    this.itemListeners();
-  }
+// export class ChunksManager {
+//   constructor(
+//     storage,
+//     pipeService,
+//     req,
+//     util,
+//     dataService,
+//   ) {
+//     this.storage = storage;
+//     this.pipeService = pipeService;
+//     this.req = req;
+//     this.util = util;
+//     this.dataService = dataService;
+//     this.chunkApi = new ChunkAPI(req);
+//     this.itemListeners();
+//   }
 
-  async getChunk(app_id, chunk_id) {
-    try {
-      return this.dataService.getChunk(app_id, chunk_id);
-    } catch (err) {
-      console.log(err);
-      return null;
-    }
-  }
+//   async getChunk(app_id, chunk_id) {
+//     try {
+//       return this.dataService.getChunk(app_id, chunk_id);
+//     } catch (err) {
+//       console.log(err);
+//       return null;
+//     }
+//   }
 
-  async getLastChunk(app_id) {
-    try {
-      return this.chunkApi.getLastChunk(app_id);
-    } catch (err) {
-      console.log(err);
-      return null;
-    }
-  }
+//   async getLastChunk(app_id) {
+//     try {
+//       return this.chunkApi.getLastChunk(app_id);
+//     } catch (err) {
+//       console.log(err);
+//       return null;
+//     }
+//   }
 
-  async getChunks(app_id, chunk_ids) {
-    let chunks = [];
-    if(chunk_ids){
-      chunks = await Promise.all(chunk_ids.map((chunk_id) => this.getChunk(app_id, chunk_id)));
-    }
-    return chunks;
-  }
+//   async getChunks(app_id, chunk_ids) {
+//     let chunks = [];
+//     if(chunk_ids){
+//       chunks = await Promise.all(chunk_ids.map((chunk_id) => this.getChunk(app_id, chunk_id)));
+//     }
+//     return chunks;
+//   }
  
-  itemListeners() {
-  }
+//   itemListeners() {
+//   }
 
-  async getApp(app_id) {
-    if (!app_id) return null;
-    let app = this.getAppFromStorage(app_id);
-    if (!app) {
-      if (this.getAppPromises[app_id]) {
-        return this.getAppPromises[app_id];
-      }
-      this.getAppPromises[app_id] = this.getAppApi(app_id);
-      app = await this.getAppPromises[app_id];
-      if (app) {
-        this.saveAppInStorage(app);
-        this.ws.addSubscription(app_id);
-      } else {
-        return null;
-      }
-    }
-    return app;
-  }  
-}
+//   async getApp(app_id) {
+//     if (!app_id) return null;
+//     let app = this.getAppFromStorage(app_id);
+//     if (!app) {
+//       if (this.getAppPromises[app_id]) {
+//         return this.getAppPromises[app_id];
+//       }
+//       this.getAppPromises[app_id] = this.getAppApi(app_id);
+//       app = await this.getAppPromises[app_id];
+//       if (app) {
+//         this.saveAppInStorage(app);
+//         this.ws.addSubscription(app_id);
+//       } else {
+//         return null;
+//       }
+//     }
+//     return app;
+//   }  
+// }

package/GUDHUB/ChunksManager/ChunksManager.test.js

@@ -1,5 +1,6 @@
 import should from "should";
 import {GudHub} from './../gudhub.js';
+import { ChunkDataService } from "../DataService/export.js";
 
 describe("CHUNKS MANAGER", async function() {
     const auth_key = 'Z/lxMHLenEaQTvPjW5U6c3jBDwWFYZrh2F9Kxa3fbt8drvabS2u2lXQ2zI+SRmic';
@@ -9,7 +10,10 @@ describe("CHUNKS MANAGER", async function() {
     it("GET CHUNK : here we get first chunk from App", async function () {
         this.timeout(10000);
         var app = await gudhub.getApp(8263);
-        let firstChunk = await gudhub.chunksManager.getChunk(8263, app.chunks[0]);
+
+        let chunkDataService = new ChunkDataService(); //TODO args
+
+        let firstChunk = await gudhub.chunksManager.getChunk(8263, app.chunks[0]);// getapp - get firstChunk from it and then load via service or via api, maybe create here chunkDataService instance
         firstChunk.should.have.property("chunk_number");
         firstChunk.should.have.property("items_list");
         firstChunk.items_list[0].fields[0].should.have.property("history");
@@ -18,7 +22,7 @@ describe("CHUNKS MANAGER", async function() {
 
     it("GET LAST CHUNK : here we should get last chunk", async function () {
         this.timeout(5000);
-        let firstChunk = await gudhub.chunksManager.getLastChunk(8263);
+        let firstChunk = await gudhub.chunksManager.getLastChunk(8263);//
 
         firstChunk.should.have.property("chunk_number");
         firstChunk.should.have.property("items_list");
@@ -27,7 +31,7 @@ describe("CHUNKS MANAGER", async function() {
 
 
     it("GET CHUNKS : here we getting chanks from empty array []", async function () {
-        let chunkedItems = await gudhub.chunksManager.getChunks(8263, []);
+        let chunkedItems = await gudhub.chunksManager.getChunks(8263, []);//
         chunkedItems.length.should.equal(0);
     });
 
@@ -35,7 +39,7 @@ describe("CHUNKS MANAGER", async function() {
     it("GET CHUNKS : here we should receive all chunks of app", async function () {
         this.timeout(1000000);
         var app = await gudhub.getApp(8263);
-        let chunkedItems = await gudhub.chunksManager.getChunks(8263, app.chunks);
+        let chunkedItems = await gudhub.chunksManager.getChunks(8263, app.chunks);//
 
         chunkedItems[0].items_list[0].should.have.property("fields");
         chunkedItems[0].items_list[0].should.have.property("item_id");

package/GUDHUB/DataService/AppDataService.js

@@ -1,5 +1,150 @@
 import { DataService } from "./DataService.js";
+import { ChunkDataService, chunkDataServiceConf } from "./export.js";
 
 export class AppDataService extends DataService {
     //interface for indexeddb and http services
+
+    constructor(req, conf, gudhub) {
+        super();
+        this.chunkDataService = new ChunkDataService(req, chunkDataServiceConf, gudhub);
+        this.gudhub = gudhub;
+    }
+
+
+    isWithCache() {
+        return false;
+    }
+
+
+    async processRequestedApp(id, sentData) {
+
+
+        
+        
+        if (
+            !this.isWithCache()
+        ) {
+
+//   async getChunks(app_id, chunk_ids) {
+//     let chunks = [];
+//     if(chunk_ids){
+//       chunks = await Promise.all(chunk_ids.map((chunk_id) => this.getChunk(app_id, chunk_id)));
+//     }
+//     return chunks;
+//   }
+
+            // let res = await this.chunkDataService.getChunks(id, sentData.chunks);
+            let res = await Promise.all(sentData.chunks.map((chunk_id) => this.chunkDataService.getChunk(id, chunk_id)));
+            if (!res) res = [];
+
+
+
+
+
+            sentData.items_list = await this.gudhub.util.mergeChunks([
+                ...res,
+                sentData,
+            ]);
+
+
+            return sentData;
+  
+        //   this.dataService.putApp(id, nextVersion);
+
+
+            // return this.mergeAndReturnStrategy.handle(sentData, chunks);
+
+
+
+        }
+
+
+
+
+
+
+        try {
+            let cachedVersion = await this.getCached(id);
+
+            if (
+                !cachedVersion
+            ) {
+
+                //TODO maybe dont wait for chunks at first load
+
+                // let res = await this.chunkDataService.getChunks(id, sentData.chunks);
+                let res = await Promise.all(sentData.chunks.map((chunk_id) => this.chunkDataService.getChunk(id, chunk_id)));
+                if (!res) res = [];
+
+
+
+                sentData.items_list = await this.gudhub.util.mergeChunks([
+                    ...res,
+                    sentData,
+                ]);
+
+
+                // this.putInCache(id, sentData);
+    
+    
+                return sentData;
+            }
+
+
+            let newHashesList = sentData.chunks.filter(c => !cachedVersion.chunks.includes(c));
+
+
+            // let self = this;
+
+
+            // let res = await this.chunkDataService.getChunks(id, newHashesList);
+            let res = await Promise.all(newHashesList.map((chunk_id) => this.chunkDataService.getChunk(id, chunk_id)));
+            if (!res) res = [];
+
+
+
+
+            // this.chunkDataService.getChunks(id, newHashesList).then((res) => {
+
+
+                sentData.items_list = await this.gudhub.util.mergeChunks([
+                    cachedVersion,
+                    ...res,
+                    sentData,
+                ]);
+
+
+                this.gudhub.triggerAppChange(id, cachedVersion, sentData);
+
+
+                // self.putInCache(id, sentData);
+            // });
+
+
+                return sentData;
+
+
+
+            // return cachedVersion;
+            
+        } catch (error) {
+            // res = await this.chunkDataService.getChunks(id, sentData.chunks);
+            let res = await Promise.all(sentData.chunks.map((chunk_id) => this.chunkDataService.getChunk(id, chunk_id)));
+            if (!res) res = [];
+
+
+
+
+            sentData.items_list = await this.gudhub.util.mergeChunks([
+                ...res,
+                sentData,
+            ]);
+
+
+            // this.putInCache(id, sentData);
+
+
+            return sentData;
+        }
+    }
 }

package/GUDHUB/DataService/IndexedDB/IndexedDBAppService.js

@@ -12,9 +12,9 @@ import { IndexedDBService } from "./IndexedDBService.js";
 
 export class IndexedDBAppService extends AppDataService {
     constructor(req, conf, gudhub) {
-      super(req, conf);
+      super(req, conf, gudhub);
   
-      this.dataService = new AppHttpService(req);
+      this.dataService = new AppHttpService(req, conf, gudhub);
 
       let indexDBService = new IndexedDBService(conf);
 
@@ -38,6 +38,10 @@ export class IndexedDBAppService extends AppDataService {
     // indexDBAccess = new IndexedDBFacade;
 
 
+    isWithCache() {
+      return true;
+    }
+
     async getApp(id) {
       if (this.requestCache.has(id)) return this.requestCache.get(id);
 
@@ -60,8 +64,14 @@ export class IndexedDBAppService extends AppDataService {
             if (
               !cachedData
             ) {
-              dataServiceRequest.then(resolve, reject);
-              dataServiceRequest.then(data => self.putApp(id, data));
+              dataServiceRequest.then(async data => {
+                let processedData = await self.processRequestedApp(id, data);
+
+                resolve(processedData);
+
+                self.putApp(id, processedData);
+
+              }, reject);
             }
       
             if (
@@ -69,20 +79,32 @@ export class IndexedDBAppService extends AppDataService {
             ) {
               resolve(cachedData);
 
-              dataServiceRequest.then(data => {
-                self.gudhub.processAppUpd(data, cachedData);
-                self.putApp(id, data);
+              dataServiceRequest.then(async data => {
+                let processedData = await self.processRequestedApp(id, data);
+                self.putApp(id, processedData);
               });
             }
           };
       
           storeRequest.onerror = () => {
-            dataServiceRequest.then(resolve, reject);
-            dataServiceRequest.then(data => self.putApp(id, data));
+            dataServiceRequest.then(async data => {
+              let processedData = await self.processRequestedApp(id, data);
+
+              resolve(processedData);
+
+              self.putApp(id, processedData);
+
+            }, reject);
           }
         } catch (error) {
-          dataServiceRequest.then(resolve, reject);
-          dataServiceRequest.then(data => self.putApp(id, data));
+          dataServiceRequest.then(async data => {
+            let processedData = await self.processRequestedApp(id, data);
+
+            resolve(processedData);
+
+            self.putApp(id, processedData);
+
+          }, reject);
         }
       });
 
@@ -91,6 +113,44 @@ export class IndexedDBAppService extends AppDataService {
       return pr;
     }
 
+    async getCached(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);
+
+          storeRequest.onsuccess = (e) => {
+    
+            let cachedData = e.target.result;
+      
+            if (
+              !cachedData
+            ) {
+              reject();
+            }
+      
+            if (
+              cachedData
+            ) {
+              resolve(cachedData);
+            }
+          };
+      
+          storeRequest.onerror = reject;
+        } catch (error) {
+          reject();
+        }
+      });
+    
+      return pr;
+    }
+
     async putApp(id, data) {
       try {        
         const db = await this.openDatabase();

package/GUDHUB/DataService/IndexedDB/IndexedDBChunkService.js

@@ -17,14 +17,15 @@ 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);
 
+      this.gudhub = gudhub;
+
       objectAssignWithOverride(this, indexDBService);
     }
 
@@ -60,6 +61,61 @@ export class IndexedDBChunkService extends ChunkDataService {
     }
 
 
+    // 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);
 
@@ -112,6 +168,7 @@ export class IndexedDBChunkService extends ChunkDataService {
         let res = await reqPrms;
 
         this.putChunk(id, res);
+        // putPrms.then(() => self.gudhub.triggerAppUpdate(id));
   
         return reqPrms;
       }

package/GUDHUB/DataService/httpService/AppHttpService.js

@@ -1,26 +1,31 @@
 import { AppAPI } from "../../api/AppApi.js";
 import { AppDataService } from "../AppDataService.js";
+import { ChunkDataService } from "../export.js";
 import { objectAssignWithOverride } from "../utils.js";
 import { HttpService } from "./HttpService.js";
 
 export class AppHttpService extends AppDataService {
     constructor(req, conf, gudhub) {
-      super();
+      super(req, conf, gudhub);
   
       this.appApi = new AppAPI(req);
 
       let indexDBService = new HttpService(conf);
+
+
+    //   this.chunkDataService = new ChunkDataService; //TODO move to 
     
       objectAssignWithOverride(this, indexDBService);
     }
 
 
     async getApp(id) {
-        return this.appApi.getApp(id);
+        let sentData = await this.appApi.getApp(id);
+        return this.processRequestedApp(id, sentData);
     }
 
     async putApp(id, app) {
-
+        // do nothing
     }
   
     static [Symbol.hasInstance](instance) {
@@ -32,4 +37,4 @@ export class AppHttpService extends AppDataService {
             return false;
         }
     }
-}
+};