@gudhub/core 1.2.4-beta.3 → 1.2.4-beta.30

package/GUDHUB/DataService/IndexedDB/IndexedDBAppService.js

@@ -2,7 +2,14 @@ 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 { IndexedDBManager, IndexedDBService } from "./IndexedDBService.js";
+
+import { IndexedDBChunkService } from "./IndexedDBChunkService.js";
+import { chunksConf } from "./chunkDataConf.js";
+import { AppStoreManager } from "./StoreManager/managers.js";
+import { dbName, dbVersion } from "./consts.js";
+import { appsConf } from "./appDataConf.js";
+import { chunksMergeConf } from "./storeManagerConf/chunkCacheStoreManagerConf.js";
 
 
 //this should be global in project
@@ -10,25 +17,204 @@ import { IndexedDBService } from "./IndexedDBService.js";
 
 // }
 
-export class IndexedDBAppService extends AppDataService {
-    constructor(req, conf) {
-      super(req, conf);
+
+
+class IndexedDBManager1 {
+  constructor(dbName, storeName) {
+    this.dbName = dbName;
+    this.storeName = storeName;
+    this.db = null;
+    this.queue = [];
+    this.isProcessing = false;
+  }
+
+  async openDB() {
+    if (this.db) return this.db;
+
+    return new Promise((resolve, reject) => {
+      const request = indexedDB.open(this.dbName, 1);
+
+      request.onupgradeneeded = (event) => {
+        const db = event.target.result;
+        if (!db.objectStoreNames.contains(this.storeName)) {
+          db.createObjectStore(this.storeName, { keyPath: 'id', autoIncrement: true });
+        }
+      };
+
+      request.onsuccess = (event) => {
+        this.db = event.target.result;
+        resolve(this.db);
+      };
+
+      request.onerror = (event) => {
+        reject(event.target.error);
+      };
+    });
+  }
+
+  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;
+    }
+  }
+}
+
+
+
+
+
+class IndexedDBManager2 {
+  constructor(dbName, storeName) {
+    this.dbName = dbName;
+    this.storeName = storeName;
+    this.db = null;
+    this.queue = [];
+    this.isProcessing = false;
+  }
+
+  async openDB() {
+    if (this.db) return this.db;
+
+    return new Promise((resolve, reject) => {
+      const request = indexedDB.open(this.dbName, 1);
+
+      request.onupgradeneeded = (event) => {
+        const db = event.target.result;
+        if (!db.objectStoreNames.contains(this.storeName)) {
+          db.createObjectStore(this.storeName, { keyPath: 'id', autoIncrement: true });
+        }
+      };
+
+      request.onsuccess = (event) => {
+        this.db = event.target.result;
+        resolve(this.db);
+      };
+
+      request.onerror = (event) => {
+        reject(event.target.error);
+      };
+    });
+  }
+
+  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;
+    }
+  }
+}
+
+
+
+//todo андрей сказал чанки два раза грузятся
+//при первой загрузке когда нет бд ничего не отображается
+//андрей предлагает грохать бд если проблемы со сторами
+
+
+// может поменять имя на StoreAppService???? потому что я уже сделал абстракцию
+
+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);
+      // let indexDBAppStoreManager = new AppStoreManager;
+
+      this.requestCache = new Map; // id -> promise ///TODO seems irrelevant to class IndexedDBManager (could be renamed to Facade already)
+
+
+      this.gudhub = gudhub;
+
+
+      this.chunkDataService = new IndexedDBChunkService(req, chunksMergeConf, gudhub);
+
+      // let res = await this.chunkDataService.getMergedChunkForIDList(id, sentData.chunks);
+
+
+
+
+      //TODO objectAssignWithOverride here too?
+      // this.dbManager = 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;
+      
 
-      let indexDBService = new IndexedDBService(conf);
 
-      objectAssignWithOverride(this, indexDBService);
+      //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 IndexedDBAppServiceForWorker) return true;
         if (instance instanceof IndexedDBService) return true; //TODO requires multiple inheritance, thhink how to overcome it
         return false;
       } catch (error) {
-      return false;
+        return false;
       }
     }
 
@@ -36,83 +222,633 @@ 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);
 
-      let dataServiceRequest = this.dataService.getApp(id);
 
-      dataServiceRequest.then(data => this.putApp(id, data));
+      // return at first time cached app request?????? no seems for worker its ok
 
-      try {
-        let self = this;
+      let self = this;
+
+      // 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 {
+          await self.openDatabase();
 
-        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);
+          const transaction = self.db.transaction(self.store, "readonly");
+          const store = transaction.objectStore(self.store);
+        
+          const storeRequest = store.get(id);
 
-            storeRequest.onsuccess = (e) => {
+          storeRequest.onsuccess = (e) => {
+    
+            let cachedData = e.target.result;
       
-              let cachedData = e.target.result;
-        
-              if (
-                !cachedData
-              ) {
-                reject();
-              }
-        
-              if (
-                cachedData
-              ) {
-                resolve(cachedData);
-              }
-            };
-        
-            storeRequest.onerror = reject
-          } catch (error) {
-            reject();
-          }
-        });
+            if (
+              !cachedData
+            ) {
+              dataServiceRequest.then(async data => {
+                let processedData = await self.processRequestedApp(id, data);//here
+
+
+                // let comparison = this.gudhub.util.compareItems([], processedData.items_list);
 
-        self.requestCache.set(id, pr);
+                // let cached
 
-        await pr;
+                resolve(processedData);
+
+                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) {
+
+      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 putApp(id, data) {
-      try {        
-        const db = await this.openDatabase();
+      return this.storeManager.putApp(id, data);
 
-        const transaction = db.transaction(this.store, "readwrite");
-        const store = transaction.objectStore(this.store);
+      // try {        
+      //   await this.openDatabase();
 
-        store.put(data, id);
-      } catch (error) {
+      //   const transaction = this.db.transaction(this.store, "readwrite");
+      //   const store = transaction.objectStore(this.store);
+
+      //   store.put(data, id);
+      // } catch (error) {
+
+      // }
+    }
+
+    // duplicated code 2 times in 2 classes openDatabase
+
+    // async openDatabase() {
+    //   if (this.db) return this.db;
+  
+    //   return new Promise((resolve, reject) => {
+    //     const request = indexedDB.open(this.dbName, this.dbVersion);
+  
+    //     request.onsuccess = event => {
+    //       this.db = event.target.result;
+    //       resolve(this.db);
+    //     };
+    //     request.onerror = event => {
+    //       reject(event.target.error);
+    //     };
+    //   });
+    // }
+}
+
+
+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
+
+
+
+    // 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('override_npm/gudhub/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);
+
+      }
+
+
+      // todo check this for new code
+      // todo outdated code, to remove
+      if (
+        e.data.type == 'processData'
+      ) {
+      // 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?
+
+
+    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
+      return false;
+    } catch (error) {
+      return false;
     }
+  }
 
-    async openDatabase() {
-      return new Promise((resolve, reject) => {
-        const request = indexedDB.open(this.dbName, this.dbVersion);
+  //TODO use IndexedDBFacade here
+  // indexDBAccess = new IndexedDBFacade;
 
-        request.onsuccess = event => {
-          resolve(event.target.result);
-        };
-        request.onerror = event => {
-          reject(event.target.error);
-        };
+
+  isWithCache() {
+    return false; //doesnt use indexeddb
+  }
+
+  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);
+
+
+    if (
+      false
+    ) {
+
+      // 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: '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) {//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
+    }
+
+    // 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) { //TODO -> put?
+    return this.storeManager.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() {
+  //   if (this.db) return this.db;
+
+  //   return new Promise((resolve, reject) => {
+  //     const request = indexedDB.open(this.dbName, this.dbVersion);
+
+  //     request.onsuccess = event => {
+  //       this.db = event.target.result;
+  //       resolve(this.db);
+  //     };
+  //     request.onerror = event => {
+  //       reject(event.target.error);
+  //     };
+  //   });
+  // }
 }