@gudhub/core 1.1.91 → 1.2.1

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

@@ -8,7 +8,8 @@ export class AppProcessor {
     websocket,
     chunksManager,
     util,
-    activateSW
+    activateSW,
+    dataService,
   ) {
     this.storage = storage;
     this.pipeService = pipeService;
@@ -19,6 +20,7 @@ export class AppProcessor {
     this.chunksManager = chunksManager;
     this.util = util;
     this.appListeners();
+    this.dataService = dataService;
   }
 
   async createNewAppApi(app) {
@@ -77,18 +79,7 @@ export class AppProcessor {
   }
 
   async getAppApi(app_id) {
-    try {
-      const response = await this.req.get({
-        url: "/api/app/get",
-        params: {
-          app_id: app_id,
-        },
-      });
-      return response;
-    } catch (err) {
-      console.log(err);
-      return null;
-    }
+    return this.dataService.getApp(app_id);
   }
 
   getAppListFromStorage() {
@@ -266,42 +257,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/Auth/Auth.js

@@ -10,12 +10,6 @@ export class Auth {
     return user;
   }
 
-  async loginWithToken(token) {
-    const user = await this.loginWithTokenApi(token);
-    this.storage.updateUser(user);
-    return user;
-  }
-
   async logout(token) {
     const response = await this.logoutApi(token);
     return response;
@@ -64,18 +58,6 @@ export class Auth {
     }
   }
 
-  async loginWithTokenApi(token) {
-    try {
-      const user = await this.req.axiosRequest({
-        method: 'POST',
-        url: `${this.req.root}/auth/login?accesstoken=${token}`
-      });
-      return user;
-    } catch (error) {
-      console.log(error);
-    }
-  }
-
   async updateTokenApi(auth_key) {
     try {
       const user = await this.req.axiosRequest({

package/GUDHUB/Auth/Auth.test.js

@@ -1,4 +1,4 @@
-
+import should from "should";
 import {GudHub} from './../gudhub.js';
 
 describe("AUTHORIZATION", async function() {
@@ -22,16 +22,6 @@ describe("AUTHORIZATION", async function() {
         user.fullname.should.equal('Vasya Pupkin');
     })
 
-    it("Authentication with access token", async function () {
-        const gudhub = new GudHub();
-
-        const token = 'accesstoken';
-
-        const user = await gudhub.loginWithToken(token);
-
-        user.hasOwnProperty('fullname').should.equal(true);
-    })
-
     it("Signing up user", async function () {
         const gudhub = new GudHub();
         let credentials =  {

package/GUDHUB/ChunksManager/ChunksManager.js

@@ -1,60 +1,48 @@
+import { ChunkAPI } from "../api/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/DataService/AppDataService.js

@@ -0,0 +1,5 @@
+import { DataService } from "./DataService.js";
+
+export class AppDataService extends DataService {
+    //interface for indexeddb and http services
+}

package/GUDHUB/DataService/CacheAPI/index.js

@@ -0,0 +1 @@
+//TODO later if Cache API will be used

package/GUDHUB/DataService/ChunkDataService.js

@@ -0,0 +1,5 @@
+import { DataService } from "./DataService.js";
+
+export class ChunkDataService extends DataService {
+    //interface for indexeddb and http services
+}

package/GUDHUB/DataService/DataService.js

@@ -0,0 +1 @@
+export class DataService {};

package/GUDHUB/DataService/IndexedDB/IndexedDBAppService.js

@@ -0,0 +1,98 @@
+import { AppDataService } from "../AppDataService.js";
+import { ChunkCacheDataService, ChunkDataService } from "../ChunkDataService.js";
+import { AppHttpService } from "../httpService/AppHttpService.js";
+import { objectAssignWithOverride } from "../utils.js";
+import { IndexedDBService } from "./IndexedDBService.js";
+
+
+//this should be global in project
+// class IndexedDBFacade extends CacheService {
+
+// }
+
+export class IndexedDBAppService extends AppDataService {
+    constructor(req, conf) {
+      super(req, conf);
+  
+      this.dataService = new AppHttpService(req);
+
+      let indexDBService = new IndexedDBService(conf);
+
+      objectAssignWithOverride(this, indexDBService);
+    }
+
+
+    static [Symbol.hasInstance](instance) {
+      if (instance instanceof IndexedDBService) return true;
+      if (instance.chunkDataService instanceof IndexedDBAppService) return true;
+      return false;
+    }
+
+    //TODO use IndexedDBFacade here
+    // indexDBAccess = new IndexedDBFacade;
+
+
+    async getApp(id) {
+      let dataServiceRequest = this.dataService.getApp(id);
+
+      dataServiceRequest.then(data => this.putApp(id, data));
+
+      try {
+        const db = await this.openDatabase();
+        const transaction = db.transaction(this.store, "readonly");
+        const store = transaction.objectStore(this.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) {
+        return dataServiceRequest;
+      }
+    }
+
+    async putApp(id, data) {
+      try {        
+        const db = await this.openDatabase();
+
+        const transaction = db.transaction(this.store, "readwrite");
+        const store = transaction.objectStore(this.store);
+
+        store.put(data, id);
+      } catch (error) {
+
+      }
+    }
+
+    async openDatabase() {
+      return new Promise((resolve, reject) => {
+        const request = indexedDB.open(this.dbName, this.dbVersion);
+
+        request.onsuccess = event => {
+          resolve(event.target.result);
+        };
+        request.onerror = event => {
+          reject(event.target.error);
+        };
+      });
+    }
+}

package/GUDHUB/DataService/IndexedDB/IndexedDBChunkService.js

@@ -0,0 +1,110 @@
+import { ChunkCacheDataService, ChunkDataService } from "../ChunkDataService.js";
+import { ChunkHttpService } from "../httpService/ChunkHttpService.js";
+import { objectAssignWithOverride } from "../utils.js";
+import { IndexedDBService } from "./IndexedDBService.js";
+
+
+//this should be global in project
+// class IndexedDBFacade extends CacheService {
+
+// }
+
+
+
+// class ChunkCachedDataService extends ChunkDataService {
+//     dataService;
+// }
+
+
+export class IndexedDBChunkService extends ChunkDataService {
+    constructor(req, conf) {
+      super(req, conf);
+  
+      this.dataService = new ChunkHttpService(req);
+
+
+      let indexDBService = new IndexedDBService(conf);
+
+      objectAssignWithOverride(this, indexDBService);
+    }
+
+    //TODO use IndexedDBFacade here
+    // indexDBAccess = new IndexedDBFacade;
+
+
+
+    static [Symbol.hasInstance](instance) {
+      if (instance instanceof IndexedDBService) return true;
+      if (instance.chunkDataService instanceof IndexedDBChunkService) return true;
+      return false;
+    }
+
+
+
+
+    async putChunk(id, data) {
+      try {        
+        const db = await this.openDatabase();
+
+        const transaction = db.transaction(this.store, "readwrite");
+        const store = transaction.objectStore(this.store);
+
+        store.put(data, id);
+      } catch (error) {
+
+      }
+    }
+
+
+    async getChunk(app_id, id) {
+      try {
+        const db = await this.openDatabase();
+        const transaction = db.transaction(this.store, "readonly");
+        const store = transaction.objectStore(this.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.dbName, this.dbVersion);
+
+        request.onsuccess = event => {
+          resolve(event.target.result);
+        };
+        request.onerror = event => {
+          reject(event.target.error);
+        };
+      });
+    }
+}

package/GUDHUB/DataService/IndexedDB/IndexedDBService.js

@@ -0,0 +1,7 @@
+export class IndexedDBService {
+    constructor(conf) {
+        this.store = conf.store;
+        this.dbName = conf.dbName;
+        this.dbVersion = conf.dbVersion;
+    }
+}

package/GUDHUB/DataService/IndexedDB/appDataConf.js

@@ -0,0 +1,7 @@
+import { dbName, dbVersion } from "./consts.js";
+
+export const appsConf = {
+    dbName,
+    dbVersion,
+    store: 'apps',
+};

package/GUDHUB/DataService/IndexedDB/chunkDataConf.js

@@ -0,0 +1,7 @@
+import { dbName, dbVersion } from "./consts.js";
+
+export const chunksConf = {
+    dbName,
+    dbVersion,
+    store: 'chunks',
+};

package/GUDHUB/DataService/IndexedDB/consts.js

@@ -0,0 +1,2 @@
+export const dbName = "gudhub";
+export const dbVersion = 7;

package/GUDHUB/DataService/IndexedDB/init.js

@@ -0,0 +1,21 @@
+import { IS_WEB } from "../../consts.js";
+import { appsConf } from "./appDataConf.js";
+import { chunksConf } from "./chunkDataConf.js";
+import { dbName, dbVersion } from "./consts.js";
+
+
+if (
+    IS_WEB
+) {
+    const request = indexedDB.open(dbName, dbVersion);
+
+    request.onupgradeneeded = event => {
+        const db = event.target.result;
+
+        for (let store of [appsConf.store, chunksConf.store]) {
+            if (!db.objectStoreNames.contains(store)) {
+                db.createObjectStore(store);
+            }
+        }
+    };
+}

package/GUDHUB/DataService/export.js

@@ -0,0 +1,48 @@
+import { cache_app_requests, cache_chunk_requests } from "../config.js";
+import { IS_WEB } from "../consts.js";
+import { IndexedDBAppService } from "./IndexedDB/IndexedDBAppService.js";
+import { IndexedDBChunkService } from "./IndexedDB/IndexedDBChunkService.js";
+import { appsConf } from "./IndexedDB/appDataConf.js";
+import { chunksConf } from "./IndexedDB/chunkDataConf.js";
+import { AppHttpService } from "./httpService/AppHttpService.js";
+import { ChunkHttpService } from "./httpService/ChunkHttpService.js";
+
+
+import "./IndexedDB/init.js";
+
+let AppDataService;
+let ChunkDataService;
+
+let appDataServiceConf;
+let chunkDataServiceConf;
+
+
+if (
+    IS_WEB &&
+    cache_chunk_requests
+) {
+    ChunkDataService = IndexedDBChunkService;
+    chunkDataServiceConf = chunksConf;
+
+} else {
+    ChunkDataService = ChunkHttpService;
+}
+
+
+if (
+    IS_WEB &&
+    cache_app_requests
+) {
+    AppDataService = IndexedDBAppService;
+    appDataServiceConf = appsConf;
+} else {
+    AppDataService = AppHttpService;
+}
+
+
+export {
+    AppDataService,
+    ChunkDataService,
+    appDataServiceConf,
+    chunkDataServiceConf,
+};

package/GUDHUB/DataService/httpService/AppHttpService.js

@@ -0,0 +1,31 @@
+import { AppAPI } from "../../api/AppApi.js";
+import { AppDataService } from "../AppDataService.js";
+import { objectAssignWithOverride } from "../utils.js";
+import { HttpService } from "./HttpService.js";
+
+export class AppHttpService extends AppDataService {
+    constructor(req, conf) {
+      super();
+  
+      this.appApi = new AppAPI(req);
+
+      let indexDBService = new HttpService(conf);
+    
+      objectAssignWithOverride(this, indexDBService);
+    }
+
+
+    async getApp(id) {
+        return this.appApi.getApp(id);
+    }
+
+    async putApp(id, app) {
+
+    }
+  
+    static [Symbol.hasInstance](instance) {
+        if (instance instanceof AppHttpService) return true;
+        if (instance.chunkDataService instanceof HttpService) return true;
+        return false;
+    }
+}

package/GUDHUB/DataService/httpService/ChunkHttpService.js

@@ -0,0 +1,32 @@
+import { ChunkAPI } from "../../api/ChunkApi.js";
+import { ChunkDataService } from "../ChunkDataService.js";
+import { objectAssignWithOverride } from "../utils.js";
+import { HttpService } from "./HttpService.js";
+
+export class ChunkHttpService extends ChunkDataService {
+    constructor(req, conf) {
+      super();
+  
+      this.chunkApi = new ChunkAPI(req);
+
+      let indexDBService = new HttpService(conf);
+    
+      objectAssignWithOverride(this, indexDBService);
+    }
+  
+    async getChunk(app_id, id) {
+      return this.chunkApi.getChunk(app_id, id);
+    }
+  
+  
+    putChunk() {
+      //do nothing
+    }
+
+
+    static [Symbol.hasInstance](instance) {
+        if (instance instanceof ChunkHttpService) return true;
+        if (instance.chunkDataService instanceof HttpService) return true;
+        return false;
+    }
+}

package/GUDHUB/DataService/httpService/HttpService.js

@@ -0,0 +1 @@
+export class HttpService {}