@gudhub/core 1.2.4-beta.16 → 1.2.4-beta.18

package/GUDHUB/DataService/AppDataService.js

@@ -1,6 +1,10 @@
 import { DataService } from "./DataService.js";
 import { ChunkDataService, chunkDataServiceConf } from "./export.js";
 
+
+
+//TODO processRequestedApp should be checked that all code is ok !!!!!!!!!!!!!!!! Ive not ended checking
+
 export class AppDataService extends DataService {
     //interface for indexeddb and http services
 

package/GUDHUB/DataService/IndexedDB/IndexedDBAppService.js

@@ -2,10 +2,13 @@ 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";
 
 
 //this should be global in project
@@ -14,17 +17,159 @@ import { chunksConf } from "./chunkDataConf.js";
 // }
 
 
+
+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, conf, gudhub);
 
-      let indexDBService = new IndexedDBService(conf);
+      // 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;
 
@@ -33,17 +178,29 @@ export class IndexedDBAppServiceForWorker extends AppDataService {
 
 
 
+      //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;
       
 
 
       //todo worker pool?
 
-      objectAssignWithOverride(this, indexDBService);
+      this.storeManager = new AppStoreManager;
+
+
+      // objectAssignWithOverride(this, indexDBService);
+      // objectAssignWithOverride(this, new AppStoreManager);
     }
 
 
@@ -90,6 +247,63 @@ export class IndexedDBAppServiceForWorker extends AppDataService {
 
 
 
+    // }
+
+
+    //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 getApp(id) {
@@ -103,15 +317,17 @@ export class IndexedDBAppServiceForWorker extends AppDataService {
       let processedData = await self.processRequestedApp(id, data);//here
 
 
-      self.putApp(id, processedData);
+      await 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");
+          await self.openDatabase();
+
+          
+          const transaction = self.db.transaction(self.store, "readonly");
           const store = transaction.objectStore(self.store);
         
           const storeRequest = store.get(id);
@@ -191,12 +407,16 @@ export class IndexedDBAppServiceForWorker extends AppDataService {
 
     async getCached(id) {
 
+      return this.storeManager.getAppStoreManagerVersion(id); //TODO investigate method name
+
+
       let self = this;
 
       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);
@@ -228,30 +448,37 @@ export class IndexedDBAppServiceForWorker extends AppDataService {
     }
 
     async putApp(id, data) {
-      try {        
-        const db = await this.openDatabase();
+      return this.storeManager.addApp(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) {
+
+      // }
     }
 
-    async openDatabase() {
-      return new Promise((resolve, reject) => {
-        const request = indexedDB.open(this.dbName, this.dbVersion);
+    // duplicated code 2 times in 2 classes openDatabase
 
-        request.onsuccess = event => {
-          resolve(event.target.result);
-        };
-        request.onerror = event => {
-          reject(event.target.error);
-        };
-      });
-    }
+    // 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);
+    //     };
+    //   });
+    // }
 }
 
 
@@ -261,7 +488,10 @@ export class IndexedDBAppService extends AppDataService {
 
     this.dataService = new AppHttpService(req, conf, gudhub);
 
-    let indexDBService = new IndexedDBService(conf);
+    // 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;
 
@@ -272,7 +502,8 @@ export class IndexedDBAppService extends AppDataService {
 
     // 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('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));
@@ -349,7 +580,11 @@ export class IndexedDBAppService extends AppDataService {
 
     //todo worker pool?
 
-    objectAssignWithOverride(this, indexDBService);
+
+    this.storeManager = new AppStoreManager;
+
+    // objectAssignWithOverride(this, indexDBService);
+    // objectAssignWithOverride(this, new AppStoreManager());
   }
 
 
@@ -371,7 +606,7 @@ export class IndexedDBAppService extends AppDataService {
     return true;
   }
 
-  async getApp(id) {
+  async getApp(id) {//TODO -> get?
     if (this.requestCache.has(id)) return this.requestCache.get(id);
 
 
@@ -461,14 +696,18 @@ export class IndexedDBAppService extends AppDataService {
 
   //TODO page isnt loaded when indexeddb empty. Investigate getApp in IndexedDBAppService here
 
-  async getCached(id) {
+  async getCached(id) {//TODO -> getFromStore?
+
+
+    return this.storeManager.getAppStoreManagerVersion(id); //TODO investigate method name
 
     let self = this;
 
     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);
@@ -500,43 +739,56 @@ export class IndexedDBAppService extends AppDataService {
   }
 
   async has(id) {
+
     try {
-      let cached = await this.getCached(id);
+      
+      return this.storeManager.hasApp(id);
+    } catch (error) {
+      debugger
+    }
 
-      if (!cached) return false;
+    // try {
+    //   let cached = await this.getCached(id);
 
-      return true;
-    } catch(e) {
-      //todo check error type and then rethrow maybe here
+    //   if (!cached) return false;
 
-      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();
+  async putApp(id, data) { //TODO -> put?
+    return this.storeManager.addApp(id, data);
 
-      const transaction = db.transaction(this.store, "readwrite");
-      const store = transaction.objectStore(this.store);
+    // try {        
+    //   const db = await this.openDatabase();
 
-      store.put(data, id);
-    } catch (error) {
+    //   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);
-      };
-    });
-  }
+  // 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);
+  //     };
+  //   });
+  // }
 }

package/GUDHUB/DataService/IndexedDB/IndexedDBChunkService.js

@@ -2,6 +2,7 @@ import { ChunkDataService } from "../ChunkDataService.js"; // removed "ChunkCach
 import { ChunkHttpService } from "../httpService/ChunkHttpService.js";
 import { objectAssignWithOverride } from "../utils.js";
 import { IndexedDBService } from "./IndexedDBService.js";
+import { ChunkCacheStoreManager, ChunksStoreManager } from "./StoreManager/managers.js";
 
 
 //this should be global in project
@@ -22,11 +23,19 @@ export class IndexedDBChunkService extends ChunkDataService {
   
       this.dataService = new ChunkHttpService(req);
 
-      let indexDBService = new IndexedDBService(conf);
+      // 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;
 
-      objectAssignWithOverride(this, indexDBService);
+
+      this.storeManager = new ChunksStoreManager;
+
+
+      // objectAssignWithOverride(this, indexDBService);
+      // objectAssignWithOverride(this, new ChunksStoreManager);
     }
 
     //TODO use IndexedDBFacade here
@@ -44,20 +53,22 @@ export class IndexedDBChunkService extends ChunkDataService {
       }
     }
 
-
+    //todo also optimize chunks transactions etc
 
 
     async putChunk(id, data) {
-      try {        
-        const db = await this.openDatabase();
+      return this.storeManager.addChunk(id, data);
 
-        const transaction = db.transaction(this.store, "readwrite");
-        const store = transaction.objectStore(this.store);
+      // try {        
+      //   const db = await this.openDatabase(); //here
 
-        store.put(data, id);
-      } catch (error) {
+      //   const transaction = db.transaction(this.store, "readwrite");
+      //   const store = transaction.objectStore(this.store);
 
-      }
+      //   store.put(data, id);
+      // } catch (error) {
+
+      // }
     }
 
 
@@ -120,39 +131,42 @@ export class IndexedDBChunkService extends ChunkDataService {
       if (this.requestCache.has(id)) return this.requestCache.get(id);
 
       try {
-        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);
+        let pr = this.storeManager.getChunkStoreManagerVersion(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);
+        //     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
+        //       ) {
+        //         reject();
+        //       }
         
-              if (
-                cachedData
-              ) {
+        //       if (
+        //         cachedData
+        //       ) {
   
-                resolve(cachedData);
-              }
-            };
+        //         resolve(cachedData);
+        //       }
+        //     };
         
-            storeRequest.onerror = reject
-          } catch (error) {
-            reject();
-          }
-        });
+        //     storeRequest.onerror = reject
+        //   } catch (error) {
+        //     reject();
+        //   }
+        // });
 
         self.requestCache.set(id, pr);
 
@@ -174,16 +188,16 @@ export class IndexedDBChunkService extends ChunkDataService {
       }
     }
 
-    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);
-        };
-      });
-    }
+    // 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);
+    //     };
+    //   });
+    // }
 }