@gudhub/core 1.2.4-beta.5 → 1.2.4-beta.51

package/.parcelrc.appRequestWorker

@@ -0,0 +1,4 @@
+{
+  "extends": "@parcel/config-default",
+  "resolvers": ["parcel-resolver-ignore", "..."]
+}

package/GUDHUB/AppProcessor/AppProcessor.js

@@ -1,4 +1,4 @@
-import { IS_WEB } from "../consts.js";
+import { IS_BROWSER_MAIN_THREAD } from "../consts.js";
 
 export class AppProcessor {
   constructor(
@@ -6,7 +6,6 @@ export class AppProcessor {
     pipeService,
     req,
     websocket,
-    chunksManager,
     util,
     activateSW,
     dataService,
@@ -17,10 +16,11 @@ 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.util = util;
     this.appListeners();
     this.dataService = dataService;
+
+    this.appRequestCache = new Map;
   }
 
   async createNewAppApi(app) {
@@ -230,7 +230,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 +255,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 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)};
 
-    this.saveAppInStorage(receivedApp);
-    this.ws.addSubscription(app_id);
+        resolve(filtered);
+    
+        self.saveAppInStorage(filtered);
+        self.ws.addSubscription(app_id);
+      } catch (error) {
+        reject();
+      }
+    });
 
-    // This code for trash must be changed
-    // return trash ? app : {...app, items_list: app.items_list.filter(item => !item.trash)};
-    return receivedApp;
+    self.appRequestCache.set(app_id, pr);
+  
+    return pr;
   }
 
   async updateApp(app) {
@@ -319,6 +340,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 +448,10 @@ 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 +493,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.test.js

@@ -1,5 +1,9 @@
 import should from "should";
 import {GudHub} from './../gudhub.js';
+import { ChunkDataService } from "../DataService/export.js";
+
+throw new Error;
+//TODO test is outdated, Chunks Manager removed, added ChunkDataService
 
 describe("CHUNKS MANAGER", async function() {
     const auth_key = 'Z/lxMHLenEaQTvPjW5U6c3jBDwWFYZrh2F9Kxa3fbt8drvabS2u2lXQ2zI+SRmic';
@@ -9,7 +13,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 +25,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 +34,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 +42,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,40 @@
 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()
+        ) {
+
+            let res = await this.chunkDataService.getMergedChunkForIDList(id, sentData.chunks);
+
+            if (
+                res
+            ) {
+                sentData.items_list = await this.gudhub.util.mergeChunks([
+                    res,
+                    sentData,
+                ]);
+            }
+
+            return sentData;
+        }
+
+        return sentData;
+
+        // following code will work for cases with enabled cache
+    }
 }

package/GUDHUB/DataService/ChunkDataService.js

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