@gudhub/core 1.2.4-beta.6 → 1.2.4-beta.60

package/GUDHUB/DataService/IndexedDB/IndexedDBAppService.js

@@ -1,33 +1,73 @@
 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";
 
+import { IndexedDBChunkService } from "./IndexedDBChunkService.js";
+import { AppStoreManager } from "./StoreManager/managers.js";
+import { chunksMergeConf } from "./storeManagerConf/chunkCacheStoreManagerConf.js";
 
-//this should be global in project
-// class IndexedDBFacade extends CacheService {
 
-// }
+// TODO remove query parameters and check build success
+import AppRequestWorkerScript from '../../../dist/PARCEL_APP_REQUEST_WORKER_FILENAME.js';
 
-export class IndexedDBAppService extends AppDataService {
+
+
+export let WORKER_EVENTS = {
+  INIT: 1,
+  REQUEST_APP: 2,
+  PROCESS_DATA: 3,
+  DECLINE_PROCESS_DATA_REQUEST: 4,
+}
+
+// old class for worker. Contains useful code therefore isnt removed
+export class IndexedDBAppServiceForWorker extends AppDataService {
     constructor(req, conf, gudhub) {
-      super(req, conf);
+      super(req, conf, gudhub);
   
-      this.dataService = new AppHttpService(req);
+      this.dataService = new AppHttpService(req, null, gudhub);
+
+      this.requestCache = new Map; // id -> promise ///TODO seems irrelevant to class IndexedDBManager (could be renamed to Facade already)
 
-      let indexDBService = new IndexedDBService(conf);
 
       this.gudhub = gudhub;
 
-      objectAssignWithOverride(this, indexDBService);
+
+      this.chunkDataService = new IndexedDBChunkService(req, chunksMergeConf, gudhub);
+
+      // let res = await this.chunkDataService.getMergedChunkForIDList(id, sentData.chunks);
+
+
+
+
+      //TODO objectAssignWithOverride here too?
+      // this.storeBackend = new IndexedDBManager('myDatabase', 'appsStore');
+
+
+
+      //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
+
+
+
+      // this.db = null;
+      // this.queue = [];
+      // this.isProcessing = false;
+      
+
+
+      //todo worker pool?
+
+      this.storeManager = new AppStoreManager;
+
+
+      // objectAssignWithOverride(this, indexDBService);
+      // objectAssignWithOverride(this, new AppStoreManager);
     }
 
 
     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
+        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;
@@ -38,17 +78,138 @@ export class IndexedDBAppService extends AppDataService {
     // indexDBAccess = new IndexedDBFacade;
 
 
+    isWithCache() {
+      return false;
+    }
+
+    // getApp(id) {
+    //   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 */ };
+    //   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);
+    //   };
+
+
+    //   worker.onmessage = (msgEv) => {
+        
+    //   }
+
+
+
+    // }
+
+
+    //TODO для чанков с индексддб будет точно такой код поєтому может вынести его в какое-то место? например в отдельный класс
+
+
+    // async executeOperation(operation) {
+    //   await this.openDB();
+    //   return new Promise((resolve, reject) => {
+    //     const transaction = this.db.transaction(this.storeName, 'readwrite');
+    //     const store = transaction.objectStore(this.storeName);
+  
+    //     transaction.oncomplete = () => resolve();
+    //     transaction.onerror = (event) => reject(event.target.error);
+  
+    //     operation(store);
+    //   });
+    // }
+  
+    // async enqueueOperation(operation) {
+    //   this.queue.push(operation);
+  
+    //   if (!this.isProcessing) {
+    //     this.isProcessing = true;
+    //     while (this.queue.length > 0) {
+    //       const currentOperation = this.queue.shift();
+    //       try {
+    //         await this.executeOperation(currentOperation);
+    //       } catch (error) {
+    //         console.error('Operation failed:', error);
+    //       }
+    //     }
+    //     this.isProcessing = false;
+    //   }
+    // }
+  
+    // async addData(data) {
+    //   await this.enqueueOperation((store) => {
+    //     store.add(data);
+    //   });
+    // }
+  
+    // async updateData(id, updatedData) {
+    //   await this.enqueueOperation((store) => {
+    //     const request = store.get(id);
+    //     request.onsuccess = () => {
+    //       const data = request.result;
+    //       Object.assign(data, updatedData);
+    //       store.put(data);
+    //     };
+    //   });
+    // }
+  
+    // async deleteData(id) {
+    //   await this.enqueueOperation((store) => {
+    //     store.delete(id);
+    //   });
+    // }
+
+
+    async getAppWithoutProcessing(id) {
+      let data = await this.dataService.getAppWithoutProcessing(id);
+
+      await this.putApp(id, data);
+
+      return data;
+    }
+
+    // this returns data for specific chunks + app request data
+    // async getAppWithSpecificChunksList(id, list) {
+    //   let data = await this.dataService.getAppWithoutProcessing(id);
+      
+    //   await self.putApp(id, data);
+
+
+    //   let processedData = await self.processRequestedApp(id, data);//here нужно пересмотреть
+
+    //   return processedData;
+    // }
+
     async getApp(id) {
-      if (this.requestCache.has(id)) return this.requestCache.get(id);
+      // if (this.requestCache.has(id)) return this.requestCache.get(id);
+
+
+      // return at first time cached app request?????? no seems for worker its ok
 
       let self = this;
 
-      let dataServiceRequest = this.dataService.getApp(id);
+      // let dataServiceRequest = this.dataService.getAppWithoutProcessing(id);
+      let data = await this.dataService.getAppWithoutProcessing(id);
+      
+      // await self.putApp(id, data);
+
+      let processedData = await self.processRequestedApp(id, data);//here нужно пересмотреть
+
+      return processedData;
 
       let pr = new Promise(async (resolve, reject) => {
         try {
-          const db = await self.openDatabase();
-          const transaction = db.transaction(self.store, "readonly");
+          await self.openDatabase();
+
+          
+          const transaction = self.db.transaction(self.store, "readonly");
           const store = transaction.objectStore(self.store);
         
           const storeRequest = store.get(id);
@@ -60,60 +221,629 @@ export class IndexedDBAppService extends AppDataService {
             if (
               !cachedData
             ) {
-              dataServiceRequest.then(resolve, reject);
-              dataServiceRequest.then(data => self.putApp(id, data));
+              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);
             }
       
             if (
               cachedData
             ) {
-              resolve(cachedData);
+              // resolve(cachedData);
+
+              dataServiceRequest.then(async data => {
+                let processedData = await self.processRequestedApp(id, data);//here
+
+                // let comparison = this.gudhub.util.compareItems(cachedData.items_list, processedData.items_list);
 
-              dataServiceRequest.then(data => {
-                self.gudhub.processAppUpd(data, cachedData);
-                self.putApp(id, data);
+                resolve(processedData);
+                self.putApp(id, processedData);
               });
             }
           };
       
           storeRequest.onerror = () => {
-            dataServiceRequest.then(resolve, reject);
-            dataServiceRequest.then(data => self.putApp(id, data));
+            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(resolve, reject);
-          dataServiceRequest.then(data => self.putApp(id, data));
+          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);
+      // self.requestCache.set(id, pr);
     
       return pr;
     }
 
-    async putApp(id, data) {
-      try {        
-        const db = await this.openDatabase();
 
-        const transaction = db.transaction(this.store, "readwrite");
-        const store = transaction.objectStore(this.store);
+    async has(id) {
 
-        store.put(data, id);
+      try {
+        
+        return this.storeManager.hasApp(id);
       } catch (error) {
+        // debugger
+      }
+    }
+
+    async getCached(id) {
+      return this.storeManager.getApp(id);
+    }
+
+    async putApp(id, data) {
+      return this.storeManager.putApp(id, data);
+    }
+}
+
+
+// this class means work directly with indexeddb without worker
+export class IndexedDBAppService extends AppDataService {
+  constructor(req, conf, gudhub) {
+    super(req, conf, gudhub);
+
+    this.dataService = new AppHttpService(req, conf, gudhub);// TODO isnt used in class. Why?
+
+    // let indexDBService = new IndexedDBService(conf);
+
+    this.requestCache = new Map; // id -> promise ///TODO seems irrelevant to class IndexedDBManager (could be renamed to Facade already)
+
+
+    this.gudhub = gudhub;
+
+
+    this.resolveFnMap = new Map; // id -> resolve
+
 
+
+    //TODO replace by worker-loader when it will work in webpack 5, take a look to webpack config
+    // let csvWorkerFileAsString = require('./csv.worker.js');
+    // let worker = new Blob([AppRequestWorkerScript], {type: 'application/javascript'});
+
+    // angular.module('csvService', [
+    //   'itemDataProcessor'
+    // ])
+
+    // .service('csvService', ['itemsDataProcessing', 'PipeService', function(itemsDataProcessing, PipeService) {
+
+      // var self = this,
+    // this.appRequestAndProcessWorker = new Worker(URL.createObjectURL(worker));//TODO URL.createObjectURL - revoke isn't called
+
+
+
+    // 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 Worker('dist/appRequestWorker.built.js', import.meta.url);
+
+
+    // const workerBlob = new Blob([atob(AppRequestWorkerScript.split(',')[1])], { type: 'application/javascript' });
+    // const workerUrl = URL.createObjectURL(workerBlob);
+    // this.appRequestAndProcessWorker = new Worker(workerUrl);
+
+    this.appRequestAndProcessWorker = new AppRequestWorkerScript;
+    // this.appRequestAndProcessWorker = new Worker(
+    //   // parcel bundler specific syntax. Check https://parceljs.org/features/bundle-inlining/
+    //   {type: 'module'}
+    // );
+    // this.appRequestAndProcessWorker = new Worker('override_npm/gudhub/umd/appRequestWorker.js');
+    // this.appRequestAndProcessWorker = new AppRequestWorker();
+
+    // new Worker(new URL('./worker.js', import.meta.url));
+
+
+    this.appRequestAndProcessWorker.postMessage({ type: WORKER_EVENTS.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 == WORKER_EVENTS.REQUEST_APP
+      ) {
+
+        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);
+
+      }
+
+
+      // todo check this for new code
+      // todo outdated code, to remove
+      if (
+        e.data.type == WORKER_EVENTS.PROCESS_DATA
+      ) {
+      // if (id == e.data.id) {
+        self.gudhub.itemProcessor.handleDiff(e.data.id, e.data.compareRes);
+
+
+        if (
+          e.data.viewListChanged ||
+          e.data.fieldListChanged
+        ) {
+          self.gudhub.appProcessor.updateAppFieldsAndViews(e.data.newVersion);
+        }
+
+
+
+
+        //here
+
+      // }
       }
+
+
+
+
+
+
+      // 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?
+
+
+    if (
+      this.isWithCache()
+    ) {
+      // move here storeManager
+      //TODO store could be with different implementations - indexeddb, cacheapi, others
     }
 
-    async openDatabase() {
-      return new Promise((resolve, reject) => {
-        const request = indexedDB.open(this.dbName, this.dbVersion);
+    this.storeManager = new AppStoreManager;
 
-        request.onsuccess = event => {
-          resolve(event.target.result);
-        };
-        request.onerror = event => {
-          reject(event.target.error);
-        };
+    // objectAssignWithOverride(this, indexDBService);
+    // objectAssignWithOverride(this, new AppStoreManager());
+  }
+
+
+  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) {//TODO -> get?
+    if (this.requestCache.has(id)) return this.requestCache.get(id); // по этому коду есть вопрос - вызовы getApp  кешируются выше и тогда выходит возвращается старая версия?
+
+
+    let self = this;
+
+
+    let hasId = await this.has(id);
+
+    hasId = false;
+
+
+    if (
+      hasId
+    ) {
+
+      // let promiseObject = Promise.
+
+      let cached = await this.getCached(id); // todo here should be merged with cached mergedChunk
+      
+      // repetitive operation again, seems should be in getCached
+      let cachedMergedChunk = await this.chunkDataService.getCachedMergedChunk(id, cached.chunks);
+
+
+      // let mergedData = this.gudhub
+
+
+      cached.items_list = await this.gudhub.util.mergeChunks([
+        cachedMergedChunk,
+        cached,
+      ]);
+
+
+      let getFromDBPrms = Promise.resolve(cached);
+      
+      // let getFromDBPrms = await this.getCached(id); // todo here should be merged with cached mergedChunk
+      this.requestCache.set(id, getFromDBPrms);
+
+      this.appRequestAndProcessWorker.postMessage({ type: WORKER_EVENTS.PROCESS_DATA, id: id });
+
+      return getFromDBPrms;
+    } else {
+      // this.requestCache.set(id, new Promise);
+
+      // todo this doesnt work as expected. Tale a look to AppThroughWebWorkerService, it has corrct implementation
+      let prms = new Promise((resolve, reject) => {
+        self.resolveFnMap.set(id, resolve);
       });
+
+
+      this.requestCache.set(id, prms);
+
+      this.appRequestAndProcessWorker.postMessage({ type: WORKER_EVENTS.REQUEST_APP, 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) {//TODO -> getFromStore?
+
+
+    return this.storeManager.getApp(id); //TODO investigate method name
+
+    let self = this;
+
+    let pr = new Promise(async (resolve, reject) => {
+      try {
+        await self.openDatabase();
+
+        const transaction = self.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 {
+      
+      return this.storeManager.hasApp(id);
+    } catch (error) {
+      debugger
+    }
+  }
+
+  async putApp(id, data) {
+    return this.storeManager.putApp(id, data);
+  }
+}
+
+export class AppHttpWorkerService extends AppDataService {
+  constructor(req, conf, gudhub) {
+    super(req, conf, gudhub);
+
+    this.dataService = new AppHttpService(req, null, gudhub);
+
+    this.requestCache = new Map; // id -> promise ///TODO seems irrelevant to class IndexedDBManager (could be renamed to Facade already)
+
+
+    this.gudhub = gudhub;
+  }
+
+
+
+  isWithCache() {
+    return false;
+  }
+
+  async getAppWithoutProcessing(id) {
+    let data = await this.dataService.getAppWithoutProcessing(id);
+
+    await this.putApp(id, data);
+
+    return data;
+  }
+
+  async getApp(id) {
+    if (this.requestCache.has(id)) return this.requestCache.get(id);
+
+
+    let resolver, rejecter;
+
+    let prms = new Promise((resolve, reject) => {
+      resolver = resolve;
+      rejecter = reject;
+    });
+
+
+    this.requestCache.set(id, prms);
+
+
+    let data = await this.dataService.getAppWithoutProcessing(id);
+    let processedData = await this.processRequestedApp(id, data);
+
+    resolver(processedData);
+
+
+    return processedData;
+  }
+
+  async has(id) {
+    return false;
+  }
+
+  async getCached(id) {
+    throw new Error;
+  }
+
+  async putApp(id, data) {
+    throw new Error;
+  }
+}
+
+
+// this means works with indexeddb and http from worker env
+export class AppIndexedDBWorkerService extends AppDataService {
+  // todo set appropriate class from config !!!!!!!!!! this or  AppHttpWorkerService
+}
+
+export class AppThroughWebWorkerService extends AppDataService {
+  constructor(req, conf, gudhub) {
+    super(req, conf, gudhub);
+
+    this.dataService = new AppHttpService(req, conf, gudhub);
+
+    this.requestCache = new Map; // id -> promise ///TODO seems irrelevant to class IndexedDBManager (could be renamed to Facade already)
+
+
+    this.gudhub = gudhub;
+
+
+    this.resolveFnMap = new Map; // id -> resolve
+
+
+    //todo worker pool?
+    this.appRequestAndProcessWorker = new AppRequestWorkerScript;
+
+
+
+    this.appRequestAndProcessWorker.postMessage({ type: WORKER_EVENTS.INIT, gudhubSerialized: this.gudhub.serialized });
+
+
+    let self = this;
+    this.appRequestAndProcessWorker.onerror = function(e) {
+      // self.appRequestAndProcessWorker.terminate();
+      //   // worker.terminate();
+      // console.error('Error in worker:', e);
+    };
+
+  
+    this.appRequestAndProcessWorker.onmessage = function(e) {
+
+      if (
+        e.data.type == WORKER_EVENTS.REQUEST_APP
+      ) {
+
+        if (
+          self.resolveFnMap.has(e.data.id)
+        ) {
+          let resolver = self.resolveFnMap.get(e.data.id);
+  
+          resolver(e.data.data);
+        }
+      }
+
+      if (
+        e.data.type == WORKER_EVENTS.PROCESS_DATA
+      ) {
+        self.gudhub.itemProcessor.handleDiff(e.data.id, e.data.compareRes);
+
+
+        if (
+          e.data.viewListChanged ||
+          e.data.fieldListChanged
+        ) {
+          self.gudhub.appProcessor.updateAppFieldsAndViews(e.data.newVersion);
+        }
+      }
+    };
+  
+
+    if (
+      this.isWithCache()
+    ) {
+      // return false;
+      // move here storeManager
+      //TODO store could be with different implementations - indexeddb, cacheapi, others
+    }
+
+    this.storeManager = new AppStoreManager;
+  }
+
+
+  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;
+    }
+  }
+
+  isWithCache() {
+    return false;
+  }
+
+  //TODO -> rename to get ? Also should be for all derived classes and class tree
+  async getApp(id) {
+    if (this.requestCache.has(id)) return this.requestCache.get(id); // по этому коду есть вопрос - вызовы getApp  кешируются выше и тогда выходит возвращается старая версия?
+
+
+    let resolver, rejecter;
+    let prms = new Promise((resolve, reject) => {
+      resolver = resolve;
+      rejecter = reject;
+    });
+
+    this.resolveFnMap.set(id, resolver);
+
+    this.requestCache.set(id, prms);
+
+    this.appRequestAndProcessWorker.postMessage({ type: WORKER_EVENTS.REQUEST_APP, id: id });
+
+
+
+    return prms;
+  }
+
+  async getCached(id) {//TODO -> getFromStore?
+    return this.storeManager.getApp(id); //TODO investigate method name
+  }
+
+  async has(id) {
+
+    try {
+      
+      return this.storeManager.hasApp(id);
+    } catch (error) {
+      debugger
+    }
+  }
+
+  async putApp(id, data) {
+    return this.storeManager.putApp(id, data);
+  }
 }