@gudhub/core 1.2.4-beta.0 → 1.2.4-beta.10

package/GUDHUB/DataService/IndexedDB/IndexedDBAppService.js

@@ -4,86 +4,227 @@ import { AppHttpService } from "../httpService/AppHttpService.js";
 import { objectAssignWithOverride } from "../utils.js";
 import { IndexedDBService } from "./IndexedDBService.js";
 
+import { IndexedDBChunkService } from "./IndexedDBChunkService.js";
+import { chunksConf } from "./chunkDataConf.js";
+
 
 //this should be global in project
 // class IndexedDBFacade extends CacheService {
 
 // }
 
-export class IndexedDBAppService extends AppDataService {
-    constructor(req, conf) {
-      super(req, conf);
+
+//todo андрей сказал чанки два раза грузятся
+//при первой загрузке когда нет бд ничего не отображается
+//андрей предлагает грохать бд если проблемы со сторами
+
+export class IndexedDBAppServiceForWorker extends AppDataService {
+    constructor(req, conf, gudhub) {
+      super(req, conf, gudhub);
   
-      this.dataService = new AppHttpService(req);
+      this.dataService = new AppHttpService(req, conf, gudhub);
 
       let indexDBService = new IndexedDBService(conf);
 
+      this.gudhub = gudhub;
+
+
+      this.chunkDataService = new IndexedDBChunkService(req, chunksConf, gudhub);
+
+
+
+      //TODO also think how to use AppDataService without overriding chunkDataService here. seems it gets http chunk service for worker somehow
+      // maybe IS_WEB is wrong inside worker
+
+
+
+      
+
+
+      //todo worker pool?
+
       objectAssignWithOverride(this, indexDBService);
     }
 
 
     static [Symbol.hasInstance](instance) {
-      if (instance instanceof IndexedDBService) return true;
-      if (instance.chunkDataService instanceof IndexedDBAppService) return true;
-      return false;
+      try {
+        if (instance instanceof IndexedDBAppServiceForWorker) return true;
+        if (instance instanceof IndexedDBService) return true; //TODO requires multiple inheritance, thhink how to overcome it
+        return false;
+      } catch (error) {
+        return false;
+      }
     }
 
     //TODO use IndexedDBFacade here
     // indexDBAccess = new IndexedDBFacade;
 
 
-    async getApp(id) {
-      if (this.requestCache.has(id)) return this.requestCache.get(id);
+    isWithCache() {
+      return true;
+    }
 
-      let dataServiceRequest = this.dataService.getApp(id);
+    // getApp(id) {
+    //   let worker = new Worker('../../appRequestWorker.js');
 
-      dataServiceRequest.then(data => this.putApp(id, data));
 
-      try {
-        let self = this;
+    //   worker.postMessage({ type: 'init', gudhubSerialized: this.gudhub.serialized });
 
-        let pr = new Promise(async (resolve, reject) => {
-          try {
-            const db = await self.openDatabase();
-            const transaction = db.transaction(self.store, "readonly");
-            const store = transaction.objectStore(self.store);
-          
-            const storeRequest = store.get(id);
+    //   // Send the main data to be processed
+    //   const mainData = { /* your data here */ };
+    //   worker.postMessage({ type: 'processData', data: mainData });
+    
+    //   worker.onmessage = function(e) {
+    //     console.log('Data processed by worker:', e.data);
+    //   };
+    
+    //   worker.onerror = function(e) {
+    //     console.error('Error in worker:', e);
+    //   };
 
-            storeRequest.onsuccess = (e) => {
-      
-              let cachedData = e.target.result;
-        
-              if (
-                !cachedData
-              ) {
-                reject();
-              }
+
+    //   worker.onmessage = (msgEv) => {
         
-              if (
-                cachedData
-              ) {
-                resolve(cachedData);
-              }
-            };
+    //   }
+
+
+
+    // }
+
+    async getApp(id) {
+      // if (this.requestCache.has(id)) return this.requestCache.get(id);
+
+      let self = this;
+
+      // let dataServiceRequest = this.dataService.getAppWithoutProcessing(id);
+      let data = await this.dataService.getAppWithoutProcessing(id);
+
+      let processedData = await self.processRequestedApp(id, data);//here
+
+
+      self.putApp(id, processedData);
+
+
+      return processedData;
+
+      let pr = new Promise(async (resolve, reject) => {
+        try {
+          const db = await self.openDatabase();
+          const transaction = db.transaction(self.store, "readonly");
+          const store = transaction.objectStore(self.store);
         
-            storeRequest.onerror = reject
-          } catch (error) {
-            reject();
-          }
-        });
+          const storeRequest = store.get(id);
+
+          storeRequest.onsuccess = (e) => {
+    
+            let cachedData = e.target.result;
+      
+            if (
+              !cachedData
+            ) {
+              dataServiceRequest.then(async data => {
+                let processedData = await self.processRequestedApp(id, data);//here
+
+
+                // let comparison = this.gudhub.util.compareItems([], processedData.items_list);
+
+                // let cached
 
-        self.requestCache.set(id, pr);
+                resolve(processedData);
 
-        await pr;
+                self.putApp(id, processedData);
+
+              }, reject);
+            }
       
-        return pr;
+            if (
+              cachedData
+            ) {
+              // resolve(cachedData);
 
-      } catch(e) {
-        this.requestCache.set(id, dataServiceRequest);
+              dataServiceRequest.then(async data => {
+                let processedData = await self.processRequestedApp(id, data);//here
 
-        return dataServiceRequest;
-      }
+                // let comparison = this.gudhub.util.compareItems(cachedData.items_list, processedData.items_list);
+
+                resolve(processedData);
+                self.putApp(id, processedData);
+              });
+            }
+          };
+      
+          storeRequest.onerror = () => {
+            dataServiceRequest.then(async data => {
+              let processedData = await self.processRequestedApp(id, data);//here
+
+              // let comparison = this.gudhub.util.compareItems([], processedData.items_list);
+
+              // let cached
+
+              resolve(processedData);
+
+              self.putApp(id, processedData);
+
+            }, reject);
+          }
+        } catch (error) {
+          dataServiceRequest.then(async data => {
+            let processedData = await self.processRequestedApp(id, data);//here
+
+            // let comparison = this.gudhub.util.compareItems([], processedData.items_list);
+
+            // let cached
+
+            resolve(processedData);
+
+            self.putApp(id, processedData);
+
+          }, reject);
+        }
+      });
+
+      // self.requestCache.set(id, pr);
+    
+      return pr;
+    }
+
+    async getCached(id) {
+
+      let self = this;
+
+      let pr = new Promise(async (resolve, reject) => {
+        try {
+          const db = await self.openDatabase();
+          const transaction = db.transaction(self.store, "readonly");
+          const store = transaction.objectStore(self.store);
+        
+          const storeRequest = store.get(id);
+
+          storeRequest.onsuccess = (e) => {
+    
+            let cachedData = e.target.result;
+      
+            if (
+              !cachedData
+            ) {
+              reject();
+            }
+      
+            if (
+              cachedData
+            ) {
+              resolve(cachedData);
+            }
+          };
+      
+          storeRequest.onerror = reject;
+        } catch (error) {
+          reject();
+        }
+      });
+    
+      return pr;
     }
 
     async putApp(id, data) {
@@ -111,4 +252,291 @@ export class IndexedDBAppService extends AppDataService {
         };
       });
     }
+}
+
+
+export class IndexedDBAppService extends AppDataService {
+  constructor(req, conf, gudhub) {
+    super(req, conf, gudhub);
+
+    this.dataService = new AppHttpService(req, conf, gudhub);
+
+    let indexDBService = new IndexedDBService(conf);
+
+    this.gudhub = gudhub;
+
+
+    this.resolveFnMap = new Map; // id -> resolve
+
+
+
+    // this.appRequestAndProcessWorker = new Worker('./appRequestWorker.js');
+    // this.appRequestAndProcessWorker = new Worker(new URL('./appRequestWorker.js', import.meta.url));
+    this.appRequestAndProcessWorker = new Worker('node_modules/@gudhub/core/umd/appRequestWorker.js');
+    // this.appRequestAndProcessWorker = new AppRequestWorker();
+
+    // new Worker(new URL('./worker.js', import.meta.url));
+
+
+    this.appRequestAndProcessWorker.postMessage({ type: 'init', gudhubSerialized: this.gudhub.serialized });
+
+
+    let self = this;
+    this.appRequestAndProcessWorker.onerror = function(e) {
+      // self.appRequestAndProcessWorker.terminate();
+
+
+      // console.error('Error in worker:', e);
+    };
+
+
+    // let self = this;
+  
+    this.appRequestAndProcessWorker.onmessage = function(e) {
+
+
+
+
+
+      if (
+        e.data.type == 'requestApp'
+      ) {
+
+        if (
+          self.resolveFnMap.has(e.data.id)
+        ) {
+          let resolver = self.resolveFnMap.get(e.data.id);
+  
+          resolver(e.data.data);
+        }
+  
+  
+        // self.requestCache.set(id, new Promise);
+
+      }
+
+
+
+      if (
+        e.data.type == 'processData'
+      ) {
+      // if (id == e.data.id) {
+        self.gudhub.itemProcessor.handleDiff(e.data.id, e.data.compareRes);
+      // }
+      }
+
+
+
+
+
+
+      // worker.terminate();
+
+      // this.postMessage({id: e.data.id, compareRes: comparison});
+
+
+      // console.log('Data processed by worker:', e.data);
+    };
+  
+    // worker.onerror = function(e) {
+    //   // worker.terminate();
+
+
+    //   // console.error('Error in worker:', e);
+    // };
+    
+
+
+    //todo worker pool?
+
+    objectAssignWithOverride(this, indexDBService);
+  }
+
+
+  static [Symbol.hasInstance](instance) {
+    try {
+      if (instance instanceof IndexedDBAppService) return true;
+      if (instance instanceof IndexedDBService) return true; //TODO requires multiple inheritance, thhink how to overcome it
+      return false;
+    } catch (error) {
+      return false;
+    }
+  }
+
+  //TODO use IndexedDBFacade here
+  // indexDBAccess = new IndexedDBFacade;
+
+
+  isWithCache() {
+    return true;
+  }
+
+  async getApp(id) {
+    if (this.requestCache.has(id)) return this.requestCache.get(id);
+
+
+    let self = this;
+
+
+    let hasId = await this.has(id);
+
+
+    if (
+      hasId
+    ) {
+      let getFromDBPrms = this.getCached(id);
+
+      this.requestCache.set(id, getFromDBPrms);
+
+      this.appRequestAndProcessWorker.postMessage({ type: 'processData', id: id });
+
+      return getFromDBPrms;
+    } else {
+      // this.requestCache.set(id, new Promise);
+
+      let prms = new Promise((resolve, reject) => {
+        self.resolveFnMap.set(id, resolve);
+      });
+
+
+      this.requestCache.set(id, prms);
+
+      //todo define types as constants
+      this.appRequestAndProcessWorker.postMessage({ type: 'requestApp', id: id });
+
+
+
+      return prms;
+
+      //todo somehow handle answer from worker
+
+      //maybe use mesage library to communicate with worker
+    }
+
+
+
+
+    // let worker = new Worker('./appRequestWorker.js');
+
+
+    // worker.postMessage({ type: 'init', gudhubSerialized: this.gudhub.serialized });
+
+    // Send the main data to be processed
+    // const mainData = { /* your data here */ };
+    // this.appRequestAndProcessWorker.postMessage({ type: 'processData', id: id });
+
+    // let self = this;
+  
+    // worker.onmessage = function(e) {
+
+
+    //   if (id == e.data.id) {
+    //     self.gudhub.itemProcessor.handleDiff(e.data.id, e.data.compareRes);
+    //   }
+
+
+
+    //   // worker.terminate();
+
+    //   // this.postMessage({id: e.data.id, compareRes: comparison});
+
+
+    //   // console.log('Data processed by worker:', e.data);
+    // };
+  
+    // worker.onerror = function(e) {
+    //   // worker.terminate();
+
+
+    //   // console.error('Error in worker:', e);
+    // };
+
+
+    // return getFromDBPrms;
+
+
+
+  }
+
+
+  //TODO page isnt loaded when indexeddb empty. Investigate getApp in IndexedDBAppService here
+
+  async getCached(id) {
+
+    let self = this;
+
+    let pr = new Promise(async (resolve, reject) => {
+      try {
+        const db = await self.openDatabase();
+        const transaction = db.transaction(self.store, "readonly");
+        const store = transaction.objectStore(self.store);
+      
+        const storeRequest = store.get(id);
+
+        storeRequest.onsuccess = (e) => {
+  
+          let cachedData = e.target.result;
+    
+          if (
+            !cachedData
+          ) {
+            reject();
+          }
+    
+          if (
+            cachedData
+          ) {
+            resolve(cachedData);
+          }
+        };
+    
+        storeRequest.onerror = reject;
+      } catch (error) {
+        reject();
+      }
+    });
+  
+    return pr;
+  }
+
+  async has(id) {
+    try {
+      let cached = await this.getCached(id);
+
+      if (!cached) return false;
+
+      return true;
+    } catch(e) {
+      //todo check error type and then rethrow maybe here
+
+      return false;
+    }
+  }
+
+  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) {
+
+    }
+  }
+
+  //todo openDatabase only once and then preserve it for further usage
+  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

@@ -17,14 +17,15 @@ import { IndexedDBService } from "./IndexedDBService.js";
 
 
 export class IndexedDBChunkService extends ChunkDataService {
-    constructor(req, conf) {
+    constructor(req, conf, gudhub) {
       super(req, conf);
   
       this.dataService = new ChunkHttpService(req);
 
-
       let indexDBService = new IndexedDBService(conf);
 
+      this.gudhub = gudhub;
+
       objectAssignWithOverride(this, indexDBService);
     }
 
@@ -34,9 +35,13 @@ export class IndexedDBChunkService extends ChunkDataService {
 
 
     static [Symbol.hasInstance](instance) {
-      if (instance instanceof IndexedDBService) return true;
-      if (instance.chunkDataService instanceof IndexedDBChunkService) return true;
-      return false;
+      try {
+        if (instance instanceof IndexedDBChunkService) return true;
+        if (instance instanceof IndexedDBService) return true; //TODO requires multiple inheritance, thhink how to overcome it
+        return false;
+      } catch (error) {
+        return false;
+      }
     }
 
 
@@ -56,6 +61,61 @@ export class IndexedDBChunkService extends ChunkDataService {
     }
 
 
+    // async getApp(id) {
+    //   if (this.requestCache.has(id)) return this.requestCache.get(id);
+
+    //   let self = this;
+
+    //   let dataServiceRequest = this.dataService.getApp(id);
+
+    //   let pr = new Promise(async (resolve, reject) => {
+    //     try {
+    //       const db = await self.openDatabase();
+    //       const transaction = db.transaction(self.store, "readonly");
+    //       const store = transaction.objectStore(self.store);
+        
+    //       const storeRequest = store.get(id);
+
+    //       storeRequest.onsuccess = (e) => {
+    
+    //         let cachedData = e.target.result;
+      
+    //         if (
+    //           !cachedData
+    //         ) {
+    //           dataServiceRequest.then(resolve, reject);
+    //           dataServiceRequest.then(data => self.putApp(id, data));
+    //         }
+      
+    //         if (
+    //           cachedData
+    //         ) {
+    //           resolve(cachedData);
+
+    //           dataServiceRequest.then(async (data) => {
+    //             // self.gudhub.processAppUpd(data, cachedData);//
+    //             await self.putApp(id, data);
+    //             self.gudhub.triggerAppUpdate(id, prevVersion, newVersion);
+    //           });
+    //         }
+    //       };
+      
+    //       storeRequest.onerror = () => {
+    //         dataServiceRequest.then(resolve, reject);
+    //         dataServiceRequest.then(data => self.putApp(id, data));
+    //       }
+    //     } catch (error) {
+    //       dataServiceRequest.then(resolve, reject);
+    //       dataServiceRequest.then(data => self.putApp(id, data));
+    //     }
+    //   });
+
+    //   self.requestCache.set(id, pr);
+    
+    //   return pr;
+    // }
+
+
     async getChunk(app_id, id) {
       if (this.requestCache.has(id)) return this.requestCache.get(id);
 
@@ -108,6 +168,7 @@ export class IndexedDBChunkService extends ChunkDataService {
         let res = await reqPrms;
 
         this.putChunk(id, res);
+        // putPrms.then(() => self.gudhub.triggerAppUpdate(id));
   
         return reqPrms;
       }