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

package/GUDHUB/DataService/IndexedDB/IndexedDBService.js

@@ -1,9 +1,334 @@
+import { appsConf } from "./appDataConf.js";
+import { chunksConf } from "./chunkDataConf.js";
+import { dbName, dbVersion } from "./consts.js";
+import { chunksMergeConf } from "./storeManagerConf/chunkCacheStoreManagerConf.js";
+
+
+// этот класс для наследования был создан, т.е. надо подумать как его скомпоновать с IndexedDBManager
 export class IndexedDBService {
     constructor(conf) {
         this.store = conf.store;
         this.dbName = conf.dbName;
         this.dbVersion = conf.dbVersion;
 
-        this.requestCache = new Map; // id -> promise
+        this.requestCache = new Map; // id -> promise ///TODO seems irrelevant to class IndexedDBManager (could be renamed to Facade already)
+    }
+}
+
+
+//Maybe rename to Facade
+export class IndexedDBManager {
+    constructor(
+      dbName, 
+      // dbVersion, 
+      storeNameList,
+    ) {
+      if (
+        !IndexedDBManager.dbNameToInstanceMap
+      ) {
+        IndexedDBManager.dbNameToInstanceMap = new Map;
+      }
+
+      if (
+        IndexedDBManager.dbNameToInstanceMap.has(dbName)
+      ) return IndexedDBManager.dbNameToInstanceMap.get(dbName);
+
+      this.db = null;
+      // this.queue = [];
+      // this.isProcessing = false;
+
+      this.dbName = dbName;
+      // this.dbVersion = dbVersion;
+      this.storeNameList = storeNameList;
+      // this.storeNameList = [];
+
+      IndexedDBManager.dbNameToInstanceMap.set(dbName, this);
+
+
+      // this.db = new Promise((resolve, reject) => {
+
+      // });
+
+
+      // this.db = this.openDB();
+
+      // this 
+
+      // this.openDB();
+    }
+
+    // TODO also remove outdated stores
+    async checkAndCreateStore(storeName) {
+      const databases = await indexedDB.databases();
+      const dbInfo = databases.find(db => db.name === this.dbName);
+
+      let storeExists = false;
+
+      let self = this;
+
+      if (
+        dbInfo
+      ) {
+          storeExists = await new Promise((resolve, reject) => {
+              const request = indexedDB.open(self.dbName);
+
+              request.onsuccess = function(event) {
+                  const db = event.target.result;
+                  const exists = db.objectStoreNames.contains(storeName);
+                  db.close();
+                  resolve(exists);
+              };
+
+              request.onerror = function(event) {
+                  reject(event.target.error);
+              };
+          });
+
+          //TODO try catch for promise reject
+      }
+
+      if (
+        !storeExists
+      ) {
+          return new Promise((resolve, reject) => {
+              const request = indexedDB.open(self.dbName, dbInfo ? dbInfo.version + 1 : 1);
+
+              request.onupgradeneeded = function(event) {
+                  const db = event.target.result;
+                  if (
+                    !db.objectStoreNames.contains(storeName)
+                  ) {
+                      db.createObjectStore(storeName);
+                  }
+              };
+
+              request.onsuccess = function(event) {
+                  const db = event.target.result;
+                  db.close();
+                  resolve();
+              };
+
+              request.onerror = reject;
+          });
+
+
+          //TODO try catch for reject
+      }
+
+      //TODO maybe not return anything it will be ok for promise resolve
+      return true;
     }
-}
+
+// // Usage example
+// checkAndCreateStore('myDatabase', 'myObjectStore').then(() => {
+//   console.log('Check and creation (if necessary) complete.');
+// }).catch(error => {
+//   console.error('Error checking and creating object store:', error);
+// });
+
+  
+    async openDB() {
+
+      // TODO remove outdated stores before also
+
+
+      if (this.db) return this.db;
+
+      for (let storeName of this.storeNameList) {
+        await this.checkAndCreateStore(storeName);
+      }
+
+
+
+      let self = this;
+  
+      return new Promise((resolve, reject) => {
+        // const request = indexedDB.open(this.dbName, this.dbVersion);
+        const request = indexedDB.open(self.dbName);
+  
+        // request.onupgradeneeded = (event) => {
+        //   const db = event.target.result;
+
+        //   this.storeNameList.forEach(storeName => {
+        //     if (
+        //       !db.objectStoreNames.contains(storeName)
+        //     ) {
+        //       db.createObjectStore(storeName);
+        //     }
+        //   });
+        // };
+  
+        request.onsuccess = (event) => {
+          self.db = event.target.result;
+
+          // let version = this.db.version;
+
+          resolve(self.db);
+        };
+  
+        request.onerror = reject;
+      });
+    }
+  
+    async executeOperation(storeName, operation) {
+
+      await this.openDB();
+
+      // if (
+      //   !this.db
+      // ) {
+      //   throw new Error("Database not initialized. Call openDB first.");
+      // }
+
+
+      // await this.db;
+
+
+      let self = this;
+
+      // await this.db;
+  
+      return new Promise((resolve, reject) => {
+        const transaction = self.db.transaction(storeName, 'readwrite'); //TODO not all operations readwrite
+        const store = transaction.objectStore(storeName);
+  
+        transaction.oncomplete = () => resolve();
+        transaction.onerror = (event) => reject(`Transaction failed: ${event.target.error}`);
+  
+        try {
+          operation(store);
+        } catch (error) {
+          reject(`Operation failed: ${error.message}`);
+        }
+      });
+    }
+  
+
+    // в инете пишут что индексдб сам хендлит транзакции, может не нужно вообще городить эти конструкции
+
+
+    // async enqueueOperation(storeName, type, operation) {
+    //   await this.ensureStoreExists(storeName); // Ensure the store exists <-----------------------
+    //   const db = await this.dbPromise;
+    //   return new Promise((resolve, reject) => {
+    //     const transaction = db.transaction(storeName, type);
+    //     const store = transaction.objectStore(storeName);
+    //     const request = operation(store);
+  
+    //     request.onsuccess = (event) => {
+    //       resolve(event.target.result);
+    //     };
+  
+    //     request.onerror = (event) => {
+    //       reject(event.target.error);
+    //     };
+    //   });
+    // }
+
+
+    async enqueueOperation(storeName, operation) {
+      this.queue.push({ storeName, operation });
+  
+      if (!this.isProcessing) {
+        this.isProcessing = true;
+        while (this.queue.length > 0) {
+          const { storeName, operation } = this.queue.shift();
+          try {
+            await this.executeOperation(storeName, operation);
+          } catch (error) {
+            console.error('Operation failed:', error);
+          }
+        }
+        this.isProcessing = false;
+      }
+    }
+
+    // единственное что тут не нравится - версия динамически меняется
+    async ensureStoreExists(storeName) {
+
+    }
+
+
+    // async ensureStoreExists(storeName) {
+    //   const db = await this.dbPromise;
+    //   if (!db.objectStoreNames.contains(storeName)) {
+    //     this.db.close();
+    //     const version = db.version + 1;
+    //     const request = indexedDB.open(this.dbName, version);
+  
+    //     request.onupgradeneeded = (event) => {
+    //       const upgradedDb = event.target.result;
+    //       if (!upgradedDb.objectStoreNames.contains(storeName)) {
+    //         upgradedDb.createObjectStore(storeName, { keyPath: 'id', autoIncrement: true });
+    //       }
+    //     };
+  
+    //     return new Promise((resolve, reject) => {
+    //       request.onsuccess = (event) => {
+    //         this.db = event.target.result;
+    //         this.dbPromise = Promise.resolve(this.db); // Update the dbPromise
+    //         resolve(this.db);
+    //       };
+  
+    //       request.onerror = (event) => {
+    //         reject(event.target.error);
+    //       };
+    //     });
+    //   }
+    //   return Promise.resolve(db);
+    // }
+
+    async createObjectStore(storeName) {
+
+
+    // async createObjectStore(storeName) {
+    //   const db = await this.dbPromise;
+    //   if (!db.objectStoreNames.contains(storeName)) {
+    //     db.close();
+    //     const version = db.version + 1;
+    //     const request = indexedDB.open(this.dbName, version);
+    
+    //     request.onupgradeneeded = (event) => {
+    //       const upgradedDb = event.target.result;
+    //       if (!upgradedDb.objectStoreNames.contains(storeName)) {
+    //         upgradedDb.createObjectStore(storeName, { keyPath: 'id', autoIncrement: true });
+    //       }
+    //     };
+    
+    //     return new Promise((resolve, reject) => {
+    //       request.onsuccess = (event) => {
+    //         this.db = event.target.result;
+    //         resolve(this.db);
+    //       };
+    
+    //       request.onerror = (event) => {
+    //         reject(event.target.error);
+    //       };
+    //     });
+    //   }
+    //   return Promise.resolve(db);
+    // }
+
+    }
+  }
+  
+  export const gudhubIndexedDBManager = new IndexedDBManager(
+    dbName,
+    // dbVersion, 
+    [
+      appsConf.store,
+      chunksConf.store,
+      chunksMergeConf.store,
+    ],
+  );
+
+  // export default dbManager;  
+
+
+
+  // последний ответ посмотри, там я спрашивал можно ли не закрывать и открывать дб из каждого сторменеджера
+
+
+  // await this.ensureStoreExists(storeName); // Ensure the store exists - вот этот код вроде ок, т.е. перед выполнением след операции проверка
+
+  

package/GUDHUB/DataService/IndexedDB/StoreManager/BaseStoreManager.js

@@ -0,0 +1,111 @@
+export class BaseStoreManager {
+  // constructor(dbManager, dbName, storeName) {
+  constructor(dbManager, storeName) {
+    this.dbManager = dbManager;
+    // this.dbName = dbName;
+    this.storeName = storeName;
+    // this.dbManager.openDB(this.dbName, [this.storeName]);
+    // this.dbManager.ensureStoreExists(this.storeName);
+  }
+
+  async addItem(id, data) {
+    return new Promise(async (resolve, reject) => {
+
+      this.dbManager.executeOperation(this.storeName, (store) => {
+        const request = store.add(data, id);
+
+        request.onsuccess = resolve;
+        request.onerror = reject;
+      });
+
+    });
+  }
+
+  async hasItem(id) {
+
+    // debugger
+
+    try {
+      let item = await this.getItem(id);
+
+      if (!item) return false;
+
+      return true;
+    } catch(e) {
+      //todo check error type and then rethrow maybe here
+
+      return false;
+    }
+
+    return new Promise(async (resolve, reject) => {
+
+      this.dbManager.executeOperation(this.storeName, (store) => {
+        const request = store.get(id);
+
+        request.onsuccess = () => {
+          const data = request.result;
+          resolve(data);
+        };
+
+        request.onerror = reject;
+      });
+
+    });
+  }
+
+  async getItem(id) {
+    return new Promise(async (resolve, reject) => {
+
+      this.dbManager.executeOperation(this.storeName, (store) => {
+        const request = store.get(id);
+
+        request.onsuccess = () => {
+          const data = request.result;
+          resolve(data);
+        };
+
+        request.onerror = reject;
+      });
+
+    });
+  }
+
+  async updateItem(id, updatedItem) {
+    return new Promise(async (resolve, reject) => {
+
+      this.dbManager.executeOperation(this.storeName, (store) => {
+        const request = store.get(id);
+
+        request.onsuccess = () => {
+          const data = request.result;
+          Object.assign(data, updatedItem);
+          store.put(data, id);
+
+          //TODO wait put operation before resolve
+          resolve();
+        };
+
+        request.onerror = reject;
+      });
+
+    });
+  }
+
+  async deleteItem(id) {
+    return new Promise(async (resolve, reject) => {
+
+      this.dbManager.executeOperation(this.storeName, (store) => {
+        const request = store.delete(id);
+
+        request.onsuccess = resolve;
+        request.onerror = reject;
+      });
+
+    });
+  }
+}
+
+
+//TODO move to base class here
+// this.requestCache = new Map; // id -> promise ///TODO seems irrelevant to class IndexedDBManager (could be renamed to Facade already)
+

package/GUDHUB/DataService/IndexedDB/StoreManager/managers.js

@@ -0,0 +1,79 @@
+import { appsConf } from "../appDataConf.js";
+import { chunksConf } from "../chunkDataConf.js";
+// import { dbName } from "../consts";
+import { gudhubIndexedDBManager } from "../IndexedDBService.js";
+import { BaseStoreManager } from "./BaseStoreManager.js";
+
+export class AppStoreManager extends BaseStoreManager {
+  constructor() {
+    super(gudhubIndexedDBManager, appsConf.store);
+  }
+
+  //use item methods from BaseStoreManager !!!!!!!!!!
+
+  //TODO getApp overrides getApp from IndexedDBAppService
+  async getAppStoreManagerVersion(id) {
+
+    return this.getItem(id);
+
+    // return dbManager.enqueueOperation('apps', 'readonly', (store) => store.get(id));
+  }
+
+  async addApp(id, data) {
+    return this.addItem(id, data);
+
+    // return dbManager.enqueueOperation('apps', 'readwrite', (store) => store.add(app));
+  }
+
+  async hasApp(id) {
+    return this.hasItem(id);
+  }
+
+  async deleteApp(id) {
+    return this.deleteItem(id);
+
+    // return dbManager.enqueueOperation('apps', 'readwrite', (store) => store.delete(id));
+  }
+
+  // Additional methods specific to AppStoreManager if necessary
+}
+
+export class ChunksStoreManager extends BaseStoreManager {
+  constructor() {
+    super(gudhubIndexedDBManager, chunksConf.store);
+  }
+
+
+  async getChunkStoreManagerVersion(id) {
+
+    return this.getItem(id);
+
+    // return dbManager.enqueueOperation('apps', 'readonly', (store) => store.get(id));
+  }
+
+  async addChunk(id, chunk) {
+    return this.addItem(id, chunk);
+
+    // return dbManager.enqueueOperation('apps', 'readwrite', (store) => store.add(app));
+  }
+
+  async deleteChunk(id) {
+    return this.deleteItem(id);
+
+    // return dbManager.enqueueOperation('apps', 'readwrite', (store) => store.delete(id));
+  }
+
+
+    //use item methods from BaseStoreManager !!!!!!!
+
+
+  // Additional methods specific to ChunksStoreManager if necessary
+}
+
+export class ChunkCacheStoreManager extends BaseStoreManager {
+  constructor(dbManager) {
+    super(dbManager, 'myDatabase', 'chunkCacheStore');
+  }
+
+  // Additional methods specific to ChunkCacheStoreManager if necessary
+}

package/GUDHUB/DataService/IndexedDB/appDataConf.js

@@ -1,7 +1,7 @@
-import { dbName, dbVersion } from "./consts.js";
+// import { dbName } from "./consts.js";
 
 export const appsConf = {
-    dbName,
-    dbVersion,
+    // dbName,
+    // dbVersion,
     store: 'apps',
 };

package/GUDHUB/DataService/IndexedDB/chunkDataConf.js

@@ -1,7 +1,7 @@
-import { dbName, dbVersion } from "./consts.js";
+// import { dbName, dbVersion } from "./consts.js";
 
 export const chunksConf = {
-    dbName,
-    dbVersion,
+    // dbName,
+    // dbVersion,
     store: 'chunks',
 };

package/GUDHUB/DataService/IndexedDB/consts.js

@@ -1,2 +1,4 @@
 export const dbName = "gudhub";
-export const dbVersion = 7;
+// export const dbVersion = 7;
+
+//todo dynamic version change chatgpt used, maybe isnt good to use static  version

package/GUDHUB/DataService/IndexedDB/init.js

@@ -4,18 +4,19 @@ import { chunksConf } from "./chunkDataConf.js";
 import { dbName, dbVersion } from "./consts.js";
 
 
-if (
-    IS_BROWSER
-) {
-    const request = indexedDB.open(dbName, dbVersion);
+// //TODO move to indexeddbmanager
+// if (
+//     IS_BROWSER
+// ) {
+//     const request = indexedDB.open(dbName, dbVersion);
 
-    request.onupgradeneeded = event => {
-        const db = event.target.result;
+//     request.onupgradeneeded = event => {
+//         const db = event.target.result;
 
-        for (let store of [appsConf.store, chunksConf.store]) {
-            if (!db.objectStoreNames.contains(store)) {
-                db.createObjectStore(store);
-            }
-        }
-    };
-}
+//         for (let store of [appsConf.store, chunksConf.store]) {
+//             if (!db.objectStoreNames.contains(store)) {
+//                 db.createObjectStore(store);
+//             }
+//         }
+//     };
+// }

package/GUDHUB/DataService/IndexedDB/storeManagerConf/chunkCacheStoreManagerConf.js

@@ -0,0 +1,11 @@
+// import { dbName, dbVersion } from "./consts.js";
+
+export const chunksMergeConf = {
+    // dbName,
+    // dbVersion,
+    store: 'chunksMergeCache',
+};
+
+
+
+//seems dbname and dbversion arent required here

package/GUDHUB/DataService/IndexedDB/storeManagerConf/init.js

@@ -0,0 +1 @@
+//move appsdbcons chunksdbconf and chunkcacheconf to here

package/GUDHUB/DataService/export.js

@@ -10,6 +10,9 @@ import { ChunkHttpService } from "./httpService/ChunkHttpService.js";
 
 import "./IndexedDB/init.js";
 
+
+//TODO confs should be used only for appropriate classes therefore it doesnt make sense to export them here
+
 let AppDataService;
 let ChunkDataService;
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gudhub/core",
-  "version": "1.2.4-beta.16",
+  "version": "1.2.4-beta.18",
   "description": "",
   "main": "index.js",
   "scripts": {