@gudhub/core 1.2.4-beta.46 → 1.2.4-beta.47

package/GUDHUB/DataService/IndexedDB/IndexedDBService.js

@@ -4,346 +4,168 @@ 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 ///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.dbPrms = this.openDB();
-
-      this.db = null;
 
+export class StoreBackend { }
 
-      // this.db = this.openDB();
 
-      // this 
-
-      // this.openDB();
+export class IndexedDBManager extends StoreBackend {
+  constructor(
+    dbName,
+    storeNameList,
+  ) {
+    if (
+      !IndexedDBManager.dbNameToInstanceMap
+    ) {
+      IndexedDBManager.dbNameToInstanceMap = new Map;
     }
 
-    // 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;
+    if (
+      IndexedDBManager.dbNameToInstanceMap.has(dbName)
+    ) return IndexedDBManager.dbNameToInstanceMap.get(dbName);
 
-      let self = this;
+    this.db = null;
+    // this.queue = [];
+    // this.isProcessing = false;
 
-      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
-      }
+    this.dbName = dbName;
+    this.storeNameList = storeNameList;
 
-      if (
-        !storeExists
-      ) {
-          return new Promise((resolve, reject) => {
-              const request = indexedDB.open(self.dbName, dbInfo ? dbInfo.version + 1 : 1);
+    IndexedDBManager.dbNameToInstanceMap.set(dbName, this);
+  }
 
-              request.onupgradeneeded = function(event) {
-                  const db = event.target.result;
-                  if (
-                    !db.objectStoreNames.contains(storeName)
-                  ) {
-                      db.createObjectStore(storeName);
-                  }
-              };
+  async checkAndCreateStore(storeName) {
+    const databases = await indexedDB.databases();
+    const dbInfo = databases.find(db => db.name === this.dbName);
 
-              request.onsuccess = function(event) {
-                  const db = event.target.result;
-                  db.close();
-                  resolve();
-              };
+    let storeExists = false;
 
-              request.onerror = reject;
-          });
+    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);
+        };
 
-          //TODO try catch for reject
-      }
+        request.onerror = function (event) {
+          reject(event.target.error);
+        };
+      });
 
-      //TODO maybe not return anything it will be ok for promise resolve
-      return true;
+      //TODO try catch for promise reject
     }
 
-// // 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;
+    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);
+          }
+        };
 
-      let resolver, rejecter;
+        request.onsuccess = function (event) {
+          const db = event.target.result;
+          db.close();
+          resolve();
+        };
 
-      let dbPrms = new Promise((resolve, reject) => {
-        resolver = resolve;
-        rejecter = reject;
+        request.onerror = reject;
       });
 
-      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(this.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;
-
-          resolver(this.db);
-        };
-  
-        request.onerror = rejecter;
 
-        return dbPrms;
-      // });
+      //TODO try catch for reject
     }
-  
-    async executeOperation(storeName, operation) {
-
-      //this get executed more than 1 time
-      let db = await this.openDB();
-
-      // if (
-      //   !this.db
-      // ) {
-      //   throw new Error("Database not initialized. Call openDB first.");
-      // }
 
+    //TODO maybe not return anything it will be ok for promise resolve
+    return true;
+  }
 
-      // await this.db;
+  async openDB() {
+    if (this.db) return this.db;
 
+    let resolver, rejecter;
 
-      // let self = this;
+    let dbPrms = new Promise((resolve, reject) => {
+      resolver = resolve;
+      rejecter = reject;
+    });
 
-      // await this.db;
-  
-      return new Promise((resolve, reject) => {
-        const transaction = 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;
-      }
+    for (let storeName of this.storeNameList) {
+      await this.checkAndCreateStore(storeName);
     }
 
-    // единственное что тут не нравится - версия динамически меняется
-    async ensureStoreExists(storeName) {
+    let self = this;
 
-    }
+    const request = indexedDB.open(this.dbName);
 
+    request.onsuccess = (event) => {
+      self.db = event.target.result;
+      resolver(this.db);
+    };
 
-    // 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);
-    // }
+    request.onerror = rejecter;
 
-    }
+    return dbPrms;
   }
-  
-  export const gudhubIndexedDBManager = new IndexedDBManager(
-    dbName,
-    // dbVersion, 
-    [
-      appsConf.store,
-      chunksConf.store,
-      chunksMergeConf.store,
-    ],
-  );
 
-  // export default dbManager;  
+  async executeOperation(storeName, operation) {
 
+    // TODO this get executed more than 1 time
+    let db = await this.openDB();
 
+    return new Promise((resolve, reject) => {
+      const transaction = 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, 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;
+  //   }
+  // }
+}
 
-  // await this.ensureStoreExists(storeName); // Ensure the store exists - вот этот код вроде ок, т.е. перед выполнением след операции проверка
 
-  
+export const indexedDBStoreBackendSingleton = new IndexedDBManager(
+  dbName,
+  [
+    appsConf.store,
+    chunksConf.store,
+    chunksMergeConf.store,
+  ],
+);

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

@@ -1,17 +1,13 @@
 export class BaseStoreManager {
-  // constructor(dbManager, dbName, storeName) {
-  constructor(dbManager, storeName) {
-    this.dbManager = dbManager;
-    // this.dbName = dbName;
+  constructor(storeBackend, storeName) {
+    this.storeBackend = storeBackend;
     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) => {
+      this.storeBackend.executeOperation(this.storeName, (store) => {
         const request = store.add(data, id);
 
         request.onsuccess = resolve;
@@ -24,7 +20,7 @@ export class BaseStoreManager {
   async putItem(id, data) {
     return new Promise(async (resolve, reject) => {
 
-      this.dbManager.executeOperation(this.storeName, (store) => {
+      this.storeBackend.executeOperation(this.storeName, (store) => {
         const request = store.put(data, id);
 
         request.onsuccess = resolve;
@@ -35,9 +31,6 @@ export class BaseStoreManager {
   }
 
   async hasItem(id) {
-
-    // debugger
-
     try {
       let item = await this.getItem(id);
 
@@ -49,27 +42,12 @@ export class BaseStoreManager {
 
       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) => {
+      this.storeBackend.executeOperation(this.storeName, (store) => {
         const request = store.get(id);
 
         request.onsuccess = () => {
@@ -86,7 +64,7 @@ export class BaseStoreManager {
   async updateItem(id, updatedItem) {
     return new Promise(async (resolve, reject) => {
 
-      this.dbManager.executeOperation(this.storeName, (store) => {
+      this.storeBackend.executeOperation(this.storeName, (store) => {
         const request = store.get(id);
 
         request.onsuccess = () => {
@@ -94,7 +72,7 @@ export class BaseStoreManager {
           Object.assign(data, updatedItem);
           store.put(data, id);
 
-          //TODO wait put operation before resolve
+          //TODO wait put operation before resolve?
           resolve();
         };
 
@@ -107,7 +85,7 @@ export class BaseStoreManager {
   async deleteItem(id) {
     return new Promise(async (resolve, reject) => {
 
-      this.dbManager.executeOperation(this.storeName, (store) => {
+      this.storeBackend.executeOperation(this.storeName, (store) => {
         const request = store.delete(id);
 
         request.onsuccess = resolve;
@@ -116,9 +94,4 @@ export class BaseStoreManager {
 
     });
   }
-}
-
-
-//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

@@ -1,32 +1,24 @@
 import { appsConf } from "../appDataConf.js";
 import { chunksConf } from "../chunkDataConf.js";
-// import { dbName } from "../consts";
-import { gudhubIndexedDBManager } from "../IndexedDBService.js";
+import { indexedDBStoreBackendSingleton } from "../IndexedDBService.js";
 import { chunksMergeConf } from "../storeManagerConf/chunkCacheStoreManagerConf.js";
 import { BaseStoreManager } from "./BaseStoreManager.js";
 
 export class AppStoreManager extends BaseStoreManager {
   constructor() {
-    super(gudhubIndexedDBManager, appsConf.store);
+    super(indexedDBStoreBackendSingleton, appsConf.store);
   }
 
   async getApp(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 putApp(id, data) {
     return this.putItem(id, data);
-
-    // return dbManager.enqueueOperation('apps', 'readwrite', (store) => store.add(app));
   }
 
   async hasApp(id) {
@@ -35,79 +27,51 @@ export class AppStoreManager extends BaseStoreManager {
 
   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);
+    super(indexedDBStoreBackendSingleton, chunksConf.store);
   }
 
 
   async getChunk(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 putChunk(id, chunk) {
     return this.putItem(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 MergedChunksStoreManager extends BaseStoreManager {
   constructor() {
-    super(gudhubIndexedDBManager, chunksMergeConf.store);
+    super(indexedDBStoreBackendSingleton, chunksMergeConf.store);
   }
 
   async get(id) {
-
     return this.getItem(id);
-
-    // return dbManager.enqueueOperation('apps', 'readonly', (store) => store.get(id));
   }
 
   async add(id, chunk) {
     return this.addItem(id, chunk);
-
-    // return dbManager.enqueueOperation('apps', 'readwrite', (store) => store.add(app));
   }
 
   //TODO update here ok?
   async put(id, chunk) {
     return this.putItem(id, chunk);
-
-    // return dbManager.enqueueOperation('apps', 'readwrite', (store) => store.add(app));
   }
 
   async delete(id) {
     return this.deleteItem(id);
-
-    // return dbManager.enqueueOperation('apps', 'readwrite', (store) => store.delete(id));
   }
 }