@gudhub/core 1.2.0 → 1.2.1

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() {

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,4 +1,4 @@
-import { ChunkAPI } from "./ChunkApi.js";
+import { ChunkAPI } from "../api/ChunkApi.js";
 
 
 export class ChunksManager {

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/{ChunksManager/DataService/IndexedDBCacheService.js → DataService/IndexedDB/IndexedDBChunkService.js}

@@ -1,4 +1,7 @@
-import { ChunkDataService, HttpDataService } from "./httpDataService.js";
+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
@@ -8,34 +11,43 @@ import { ChunkDataService, HttpDataService } from "./httpDataService.js";
 
 
 
-class ChunkCachedDataService extends ChunkDataService {
-    dataService;
-}
+// class ChunkCachedDataService extends ChunkDataService {
+//     dataService;
+// }
 
 
-export class IndexedDBChunkCacheService extends ChunkCachedDataService {
-    constructor(req) {
-      super();
+export class IndexedDBChunkService extends ChunkDataService {
+    constructor(req, conf) {
+      super(req, conf);
   
-      this.dataService = new HttpDataService(req);
-    }
+      this.dataService = new ChunkHttpService(req);
 
 
-    OBJECT_STORE = "v2";
-    DatabaseName = "my-cache-db";
-    DatabaseVersion = 1;
+      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.OBJECT_STORE, "readwrite");
-        const store = transaction.objectStore(this.OBJECT_STORE);
+        const transaction = db.transaction(this.store, "readwrite");
+        const store = transaction.objectStore(this.store);
 
         store.put(data, id);
       } catch (error) {
@@ -47,8 +59,8 @@ export class IndexedDBChunkCacheService extends ChunkCachedDataService {
     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 transaction = db.transaction(this.store, "readonly");
+        const store = transaction.objectStore(this.store);
       
         const storeRequest = store.get(id);
       
@@ -85,11 +97,8 @@ export class IndexedDBChunkCacheService extends ChunkCachedDataService {
 
     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);
-        };
+        const request = indexedDB.open(this.dbName, this.dbVersion);
+
         request.onsuccess = event => {
           resolve(event.target.result);
         };

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 {}

package/GUDHUB/DataService/utils.js

@@ -0,0 +1,34 @@
+
+export let objectAssignWithoutOverride = (target, ...sourceList) => {
+    for (let source of sourceList) {
+      if (!source) continue;
+      for(let key of Object.keys(source)) {//this doesnt iterate over class like source properties
+        if (!(key in target)) {//checks own and inherited keys, works fine also for class prototypes and instances
+          const desc = Object.getOwnPropertyDescriptor(source, key);
+          if (desc.enumerable) Object.defineProperty(target, key, desc);
+        }
+      }
+    }
+  };
+  
+  export let objectAssignWithOverride = (target, ...sourceList) => {
+    for (let source of sourceList) {
+      if (!source) continue;
+      for(let key of Object.keys(source)) {//this doesnt iterate over class like source properties
+        const desc = Object.getOwnPropertyDescriptor(source, key);
+        if (desc.enumerable) Object.defineProperty(target, key, desc);
+      }
+    }
+  };
+  
+  
+  
+  export let checkInstanceModifier = (target, ...sourceList) => {
+    for (let source of sourceList) {
+      if (!source) continue;
+      for(let key of Object.keys(source)) {//this doesnt iterate over class like source properties
+        const desc = Object.getOwnPropertyDescriptor(source, key);
+        if (desc.enumerable) Object.defineProperty(target, key, desc);
+      }
+    }
+  };

package/GUDHUB/api/AppApi.js

@@ -0,0 +1,14 @@
+export class AppAPI {
+    constructor(req) {
+      this.req = req;
+    }
+  
+    async getApp(app_id) {
+      return this.req.get({
+        url: `${this.req.root}/api/app/get`,
+        params: {
+          app_id: app_id,
+        },
+      });
+    }
+  }

package/GUDHUB/config.js

@@ -8,5 +8,8 @@ export const async_modules_path = 'build/latest/async_modules_node/';
 export const automation_modules_path = 'build/latest/automation_modules/'
 export const file_server_url = 'https://gudhub.com'
 
+export const cache_chunk_requests = true;
+export const cache_app_requests = true;
+
 // FOR TESTS
 export const port = 9000;

package/GUDHUB/gudhub.js

@@ -18,7 +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";
+import { AppDataService, ChunkDataService, appDataServiceConf, chunkDataServiceConf } from "./DataService/export.js";
 
 export class GudHub {
   constructor(
@@ -32,9 +32,7 @@ export class GudHub {
       swLink: "",
       async_modules_path,
       file_server_url,
-      automation_modules_path,
-      accesstoken: this.accesstoken,
-      expirydate: this.expirydate
+      automation_modules_path
     }
   ) {
     this.config = options;
@@ -47,15 +45,7 @@ export class GudHub {
     this.auth = new Auth(this.req, this.storage);
     this.sharing = new Sharing(this, this.req);
     this.groupSharing = new GroupSharing(this, this.req, this.pipeService);
-
-    // Login with access token - pass to setUser access token and after it user can  make requests with access token
-    // This method created for optimize GudHub  initialization without auth key
-    if (authKey) {
-      this.storage.setUser({ auth_key: authKey })
-    } else if(options.accesstoken && options.expirydate) {
-      this.storage.setUser({accesstoken: options.accesstoken, expirydate: options.expirydate})
-    }
-
+    if (authKey) this.storage.setUser({ auth_key: authKey });
     this.req.init(this.auth.getToken.bind(this.auth));
 
     this.ws = new WebSocketApi(options.wss_url, this.auth);
@@ -64,7 +54,7 @@ export class GudHub {
       this.pipeService,
       this.req,
       this.util,
-      new DataService(this.req),
+      new ChunkDataService(this.req, chunkDataServiceConf),
     );
     this.appProcessor = new AppProcessor(
       this.storage,
@@ -73,7 +63,8 @@ export class GudHub {
       this.ws,
       this.chunksManager,
       this.util,
-      options.activateSW
+      options.activateSW,
+      new AppDataService(this.req, appDataServiceConf),
     );
     this.itemProcessor = new ItemProcessor(
       this.storage,
@@ -454,10 +445,6 @@ export class GudHub {
     return this.auth.login(data);
   }
 
-  loginWithToken(token) {
-    return this.auth.loginWithToken(token);
-  }
-
   logout(token) {
     this.appProcessor.clearAppProcessor();
     return this.auth.logout(token);

package/package.json

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