@gudhub/core 1.1.91 → 1.2.0

package/.vscode/launch.json

@@ -0,0 +1,31 @@
+{
+    "version": "0.2.0",
+    "configurations": [
+        {
+            "name": "Launch Program",
+            "program": "${workspaceFolder}/app.js",
+            "request": "launch",
+            "skipFiles": [
+                "<node_internals>/**"
+            ],
+            "type": "node"
+        },
+        {
+            "type": "node",
+            "request": "launch",
+            "runtimeVersion": "16",
+            "name": "Launch Program",
+            "skipFiles": [
+                "<node_internals>/**"
+            ],
+            "program": "${workspaceFolder}/index.js"
+        },
+        {
+            "type": "node-terminal",
+            "name": "Run Script: test",
+            "request": "launch",
+            "command": "npm run test",
+            "cwd": "${workspaceFolder}"
+        }
+    ]
+}

package/GUDHUB/AppProcessor/AppProcessor.js

@@ -266,42 +266,29 @@ export class AppProcessor {
     if (!app_id) return null;
 
     let app = this.getAppFromStorage(app_id);
-    if (!app) {
-      let receivedApp = await this.getAppApi(app_id);
-      if (!receivedApp) return null;
-
-      //!!! temporary check !!!! if app has chanks property then we start getting it
-      if (receivedApp.chunks && receivedApp.chunks.length) {
-        this.chunksManager
-          .getChunks(app_id, receivedApp.chunks)
-          .then((chunks) => {
-            receivedApp.items_list = this.util.mergeChunks([
-              ...chunks,
-              receivedApp,
-            ]);
-            this.saveAppInStorage(receivedApp);
-            this.pipeService.emit(
-              "gh_items_update",
-              { app_id },
-              receivedApp.items_list
-            );
-          });
-        app = receivedApp
-        this.saveAppInStorage(receivedApp);
-      } else {
-        app = this.getAppFromStorage(app_id);
-        // for oprimization purpose: we check if app was already received in case when there was severals calls at same moment of the getApp one call will overwrite the App from another call with the same App,
-        if (!app) {
-          app = receivedApp;
-          this.saveAppInStorage(receivedApp); //!!! will be saved over several times for each app request
-          this.ws.addSubscription(app_id);
-        }
-      }
+    if (app) return app;
+
+    let receivedApp = await this.getAppApi(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,
+      ]);
     }
-    
+
+    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 app;
+    return receivedApp;
   }
 
   async updateApp(app) {

package/GUDHUB/ChunksManager/ChunkApi.js

@@ -0,0 +1,19 @@
+export class ChunkAPI {
+  constructor(req) {
+    this.req = req;
+  }
+
+  async getChunk(app_id, chunk_id) {
+    return this.req.get({
+      url: `${this.req.root}/api/get-items-chunk/${app_id}/${chunk_id}`,
+      method: 'GET'
+    });
+  }
+
+  async getLastChunk(app_id) {
+      return this.req.axiosRequest({
+          url: `${this.req.root}/api/get-last-items-chunk/${app_id}`,
+          method: 'GET'
+      });
+  }
+}

package/GUDHUB/ChunksManager/ChunksManager.js

@@ -1,60 +1,48 @@
+import { ChunkAPI } from "./ChunkApi.js";
 
 
 export class ChunksManager {
-  constructor(storage, pipeService, req, util) {
+  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 getChunkApi(app_id, chunk_id) {
+  async getChunk(app_id, chunk_id) {
     try {
-      const response = await this.req.axiosRequest({
-        url: `${this.req.root}/api/get-items-chunk/${app_id}/${chunk_id}`,
-        method: 'GET'
-      });
-      return response;
+      return this.dataService.getChunk(app_id, chunk_id);
     } catch (err) {
       console.log(err);
       return null;
     }
   }
 
-  async getLastChunkApi(app_id) {
+  async getLastChunk(app_id) {
     try {
-      const response = await this.req.axiosRequest({
-        url: `${this.req.root}/api/get-last-items-chunk/${app_id}`,
-        method: 'GET'
-      });
-      return response;
+      return this.chunkApi.getLastChunk(app_id);
     } catch (err) {
       console.log(err);
       return null;
     }
   }
 
-
-  getChunk(app_id, chunk_id) {
-   return this.getChunkApi(app_id, chunk_id);
-  }
-
-
   async getChunks(app_id, chunk_ids) {
     let chunks = [];
     if(chunk_ids){
-      chunks = await Promise.all(chunk_ids.map((chunk_id) => this.getChunkApi(app_id, chunk_id)));
+      chunks = await Promise.all(chunk_ids.map((chunk_id) => this.getChunk(app_id, chunk_id)));
     }
     return chunks;
   }
-
-
-  async getLastChunk(app_id) {
-    let chunk = await this.getLastChunkApi(app_id);
-    return chunk;
-  }
-
  
   itemListeners() {
   }
@@ -76,7 +64,5 @@ export class ChunksManager {
       }
     }
     return app;
-  }
-  
-  
-}
+  }  
+}

package/GUDHUB/ChunksManager/DataService/IndexedDBCacheService.js

@@ -0,0 +1,101 @@
+import { ChunkDataService, HttpDataService } from "./httpDataService.js";
+
+
+//this should be global in project
+// class IndexedDBFacade extends CacheService {
+
+// }
+
+
+
+class ChunkCachedDataService extends ChunkDataService {
+    dataService;
+}
+
+
+export class IndexedDBChunkCacheService extends ChunkCachedDataService {
+    constructor(req) {
+      super();
+  
+      this.dataService = new HttpDataService(req);
+    }
+
+
+    OBJECT_STORE = "v2";
+    DatabaseName = "my-cache-db";
+    DatabaseVersion = 1;
+
+
+    //TODO use IndexedDBFacade here
+    // indexDBAccess = new IndexedDBFacade;
+
+
+    async putChunk(id, data) {
+      try {        
+        const db = await this.openDatabase();
+
+        const transaction = db.transaction(this.OBJECT_STORE, "readwrite");
+        const store = transaction.objectStore(this.OBJECT_STORE);
+
+        store.put(data, id);
+      } catch (error) {
+
+      }
+    }
+
+
+    async getChunk(app_id, id) {
+      try {
+        const db = await this.openDatabase();
+        const transaction = db.transaction(this.OBJECT_STORE, "readonly");
+        const store = transaction.objectStore(this.OBJECT_STORE);
+      
+        const storeRequest = store.get(id);
+      
+        return await new Promise((resolve, reject) => {
+          storeRequest.onsuccess = (e) => {
+      
+            let cachedData = e.target.result;
+      
+            if (
+              !cachedData
+            ) {
+              reject();
+            }
+      
+            if (
+              cachedData
+            ) {
+
+              resolve(cachedData);
+            }
+          };
+      
+          storeRequest.onerror = reject
+        });
+      } catch(e) {
+        let res = await this.dataService.getChunk(app_id, id);
+
+        await this.putChunk(id, res);
+  
+  
+        return res;
+      }
+    }
+
+    async openDatabase() {
+      return new Promise((resolve, reject) => {
+        const request = indexedDB.open(this.DatabaseName, this.DatabaseVersion);
+        request.onupgradeneeded = event => {
+          const db = event.target.result;
+          db.createObjectStore(this.OBJECT_STORE);
+        };
+        request.onsuccess = event => {
+          resolve(event.target.result);
+        };
+        request.onerror = event => {
+          reject(event.target.error);
+        };
+      });
+    }
+}

package/GUDHUB/ChunksManager/DataService/export.js

@@ -0,0 +1,13 @@
+import { IS_WEB } from "../../consts.js";
+import { IndexedDBChunkCacheService } from "./IndexedDBCacheService.js";
+import { HttpDataService } from "./httpDataService.js";
+
+let exportClass;
+
+if (IS_WEB) {
+    exportClass = IndexedDBChunkCacheService
+} else {
+    exportClass = HttpDataService
+}
+
+export { exportClass as DataService };

package/GUDHUB/ChunksManager/DataService/httpDataService.js

@@ -0,0 +1,21 @@
+import { ChunkAPI } from "../ChunkApi.js";
+
+export class ChunkDataService {}
+
+
+export class HttpDataService extends ChunkDataService {
+  constructor(req) {
+    super();
+
+    this.chunkApi = new ChunkAPI(req);
+  }
+
+  async getChunk(app_id, id) {
+    return this.chunkApi.getChunk(app_id, id);
+  }
+
+
+  putChunk() {
+    //do nothing
+  }
+}

package/GUDHUB/gudhub.js

@@ -18,6 +18,7 @@ import { WebsocketHandler } from './WebSocket/WebsocketHandler.js';
 import { GroupSharing } from './Utils/sharing/GroupSharing.js';
 import { Sharing } from './Utils/sharing/Sharing.js';
 import { WebSocketEmitter } from './WebSocket/WebSocketEmitter.js';
+import { DataService } from "./ChunksManager/DataService/export.js";
 
 export class GudHub {
   constructor(
@@ -62,7 +63,8 @@ export class GudHub {
       this.storage,
       this.pipeService,
       this.req,
-      this.util
+      this.util,
+      new DataService(this.req),
     );
     this.appProcessor = new AppProcessor(
       this.storage,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gudhub/core",
-  "version": "1.1.91",
+  "version": "1.2.0",
   "description": "",
   "main": "index.js",
   "scripts": {