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

package/GUDHUB/AppProcessor/AppProcessor.js

@@ -1,4 +1,4 @@
-import { IS_WEB } from "../consts.js";
+import { IS_BROWSER, IS_BROWSER_MAIN_THREAD, IS_WEB } from "../consts.js";
 
 export class AppProcessor {
   constructor(
@@ -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) {
@@ -230,7 +235,7 @@ export class AppProcessor {
       // Here we get default user's app
       // We do it here to do it only once
       // We do it because we need to initialize WebSockets, which we do in getApp method
-      this.getApp(this.storage.getUser().app_init);
+      // this.getApp(this.storage.getUser().app_init); // commented due to unfinished app_init development, its shape causes exceptions
     }
 
     return app_list;
@@ -255,27 +260,48 @@ export class AppProcessor {
     let app = this.getAppFromStorage(app_id);
     if (app) return app;
 
-    let receivedApp = await this.dataService.getApp(app_id);
-    if (!receivedApp) return;
+    if (this.appRequestCache.has(app_id)) return this.appRequestCache.get(app_id);
 
-    //!!! 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,
-      ]);
-    }
+    let self = this;
+
+    let pr = new Promise(async (resolve, reject) => {
+      try {
+        let app = await self.dataService.getApp(app_id);
+        if (!app) 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
+
+
+        //   let chunks = await self.chunksManager.getChunks(app_id, receivedApp.chunks);
+        //   receivedApp.items_list = self.util.mergeChunks([
+        //     ...chunks,
+        //     receivedApp,
+        //   ]);
+        // }
 
-    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;
+        // This code for trash must be changed
+        // return trash ? app : {...app, items_list: app.items_list.filter(item => !item.trash)};
+        let filtered =  trash ? app : {...app, items_list: app.items_list.filter(item => !item.trash)};
+        filtered =  trash ? filtered : {...filtered, field_list: filtered.field_list.filter(f => !f.trash)};
+
+        resolve(filtered);
+    
+        self.saveAppInStorage(filtered);
+        self.ws.addSubscription(app_id);
+      } catch (error) {
+        reject();
+      }
+    });
+
+    self.appRequestCache.set(app_id, pr);
+  
+    return pr;
   }
 
   async updateApp(app) {
@@ -319,6 +345,18 @@ export class AppProcessor {
     }
   }
 
+  async handleAppChange(id, prevVersion, nextVersion) {
+    let res1 = this.util.areViewListsEqual(prevVersion.views_list, nextVersion.views_list);
+    let res2 = this.util.areFieldListsEqual(prevVersion.field_list, nextVersion.field_list);
+
+    if (
+      res1 ||
+      res2
+    ) {
+      this.updateAppFieldsAndViews({id, views_list: nextVersion.views_list, field_list: nextVersion.field_list});
+    }
+  }
+
   clearAppProcessor() {
     this.getAppListPromises = null;
     this.getAppPromises = {};
@@ -415,7 +453,7 @@ export class AppProcessor {
         appsList
       );
     });
-    if (IS_WEB && this.activateSW) {
+    if (IS_BROWSER_MAIN_THREAD && this.activateSW) {
       navigator.serviceWorker.addEventListener("message", async (event) => {
         if (event.data.type === "refresh app") {
           const app = await this.getApp(event.data.payload.app_id);
@@ -457,7 +495,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]) //here check Ask Andrew
           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,237 @@
 import { DataService } from "./DataService.js";
+import { ChunkDataService, chunkDataServiceConf } from "./export.js";
+
+
+
+//TODO processRequestedApp should be checked that all code is ok !!!!!!!!!!!!!!!! Ive not ended checking
 
 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;
+    }
+
+
+    //here
+    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){
+//       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)));
+
+            let res = await this.chunkDataService.getMergedChunkForIDList(id, sentData.chunks);
+
+
+            if (
+                res
+            ) {
+                sentData.items_list = await this.gudhub.util.mergeChunks([
+                    res,
+                    sentData,
+                ]);
+            }
+
+            // if (!res) res = [];
+
+
+
+            //TODO should be in new thread too even for Node.js becauses this will block loop
+
+            // sentData.items_list = await this.gudhub.util.mergeChunks([
+            //     ...res,
+            //     sentData,
+            // ]);
+
+
+            return sentData;
+  
+        //   this.dataService.putApp(id, nextVersion);
+
+
+            // return this.mergeAndReturnStrategy.handle(sentData, chunks);
+
+
+
+        }
+
+
+
+        throw new Error;
+
+
+
+
+
+
+        try {
+
+            // я там собираюсь склеивать все данные в этом методе, надо посмотреть не будет ли проблем для ноды итп там тоже process вызывается
+            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 (
+                !cachedApp
+                // cachedMergedChunk ?
+            ) {
+
+                //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)));
+                let res = await this.chunkDataService.getMergedChunkForIDList(id, sentData.chunks);
+
+
+                if (
+                    res
+                ) {
+                    sentData.items_list = await this.gudhub.util.mergeChunks([
+                        res,
+                        sentData,
+                    ]);
+                }
+
+                // this.putInCache(id, sentData);
+    
+    
+                return sentData;
+            }
+
+
+            // let newHashesList = sentData.chunks.filter(c => !cachedApp.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)));
+
+            let res = await this.chunkDataService.getCachedMergedChunk(id, cachedApp.chunks);
+
+            // if (!res) res = [];
+
+
+
+            if (
+                res
+            ) {
+                sentData.items_list = await this.gudhub.util.mergeChunks([
+                    cachedApp,
+                    res,
+                    sentData,
+                ]);
+            } else {
+                sentData.items_list = await this.gudhub.util.mergeChunks([
+                    cachedApp,
+                    sentData,
+                ]);
+            }
+
+
+
+
+            // this.chunkDataService.getChunks(id, newHashesList).then((res) => {
+
+
+
+
+
+                //TODO check this for AppHttpService, seems isnt necessary
+                // this.gudhub.triggerAppChange(id, cachedVersion, sentData);
+
+
+                // self.putInCache(id, sentData);
+            // });
+
+
+                return sentData;
+
+
+
+            // return cachedVersion;
+            
+        } catch (error) {
+
+            // seems try catch here isnt handling almost anything, almost identical code here
+
+            // res = await this.chunkDataService.getChunks(id, sentData.chunks);
+            // let res = await Promise.all(sentData.chunks.map((chunk_id) => this.chunkDataService.getChunk(id, chunk_id)));
+            let res = await this.chunkDataService.getMergedChunkForIDList(sentData.chunks);
+
+            // if (!res) res = [];
+
+
+            if (
+                res
+            ) {
+                sentData.items_list = await this.gudhub.util.mergeChunks([
+                    res,
+                    sentData,
+                ]);
+            }
+
+            // this.putInCache(id, sentData);
+
+
+            return sentData;
+        }
+    }
 }

package/GUDHUB/DataService/ChunkDataService.js

@@ -2,4 +2,14 @@ import { DataService } from "./DataService.js";
 
 export class ChunkDataService extends DataService {
     //interface for indexeddb and http services
+
+
+    //here
+    getMergedChunkForIDList(idList) {
+        
+    }
+
+    isWithCache() {
+        return false;
+    }
 }