@gudhub/core 1.2.0 → 1.2.2

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/ChunksManager/ChunksManager.js

@@ -1,4 +1,4 @@
-import { ChunkAPI } from "./ChunkApi.js";
+import { ChunkAPI } from "../api/ChunkApi.js";
 
 
 export class ChunksManager {

package/GUDHUB/ChunksManager/DataService/IndexedDBCacheService.js

@@ -21,8 +21,8 @@ export class IndexedDBChunkCacheService extends ChunkCachedDataService {
     }
 
 
-    OBJECT_STORE = "v2";
-    DatabaseName = "my-cache-db";
+    OBJECT_STORE = "chunks";
+    DatabaseName = "gudhubapi-data";
     DatabaseVersion = 1;
 
 

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 { ChunkDataService } from "../ChunkDataService.js"; // removed "ChunkCacheDataService" from imported because it was causing an error "{ ChunkCacheDataService } not found in exported names" in "gudhub-node-server"
+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 { ChunkDataService } from "../ChunkDataService.js"; // removed "ChunkCacheDataService" from imported because it was causing an error "{ ChunkCacheDataService } not found in exported names" in "gudhub-node-server"
+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 {}

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/api/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/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(
@@ -64,7 +64,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 +73,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,

package/package.json

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