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

package/GUDHUB/DataService/IndexedDB/IndexedDBChunkService.js

@@ -1,132 +1,165 @@
-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 { ChunkDataService } from "../ChunkDataService.js";
 import { ChunkHttpService } from "../httpService/ChunkHttpService.js";
-import { objectAssignWithOverride } from "../utils.js";
-import { IndexedDBService } from "./IndexedDBService.js";
-
-
-//this should be global in project
-// class IndexedDBFacade extends CacheService {
-
-// }
-
-
-
-// class ChunkCachedDataService extends ChunkDataService {
-//     dataService;
-// }
+import { ChunksStoreManager, MergedChunksStoreManager } from "./StoreManager/managers.js";
 
 
 export class IndexedDBChunkService extends ChunkDataService {
-    constructor(req, conf) {
+    constructor(req, conf, gudhub) {
       super(req, conf);
   
       this.dataService = new ChunkHttpService(req);
 
+      this.requestCache = new Map;
 
-      let indexDBService = new IndexedDBService(conf);
-
-      objectAssignWithOverride(this, indexDBService);
-    }
-
-    //TODO use IndexedDBFacade here
-    // indexDBAccess = new IndexedDBFacade;
 
+      this.gudhub = gudhub;
 
+      this.storeManager = new MergedChunksStoreManager;
+    }
 
     static [Symbol.hasInstance](instance) {
       try {
         if (instance instanceof IndexedDBChunkService) return true;
-        if (instance instanceof IndexedDBService) return true; //TODO requires multiple inheritance, thhink how to overcome it
+        // if (instance instanceof IndexedDBService) return true; //TODO requires multiple inheritance, thhink how to overcome it
         return false;
       } catch (error) {
         return false;
       }
     }
 
+    async getCachedMergedChunk(id, chunkHashesList) {
+      try {
+        let cachedData = await this.storeManager.get(id);
 
+        return cachedData.mergedData;
+      } catch (error) {
+        const requests = chunkHashesList.map(hash => this.dataService.getChunk(id, hash));
+    
+        const newChunks = await Promise.all(requests);
 
 
-    async putChunk(id, data) {
-      try {        
-        const db = await this.openDatabase();
-
-        const transaction = db.transaction(this.store, "readwrite");
-        const store = transaction.objectStore(this.store);
+        let mergedData = await this.gudhub.util.mergeChunks(newChunks);
 
-        store.put(data, id);
-      } catch (error) {
+        this.putMergedChunks(id, {hashes: chunkHashesList, mergedData: {items_list: mergedData}});
 
+        return {items_list: mergedData};
       }
     }
 
+    isWithCache() {
+      return true;
+    }
 
-    async getChunk(app_id, id) {
-      if (this.requestCache.has(id)) return this.requestCache.get(id);
 
-      try {
-        let self = this;
+    async getMergedChunkForApp(id) {
+      // here request api and get chunks list
 
-        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);
+      //then perform all required checks for cached chunk and hashes and new hashes
+    }
+
+    //here // TODO replace this with getMergedChunkForApp in future
+    async getMergedChunkForIDList(id, chunkHashesList) {
+      try {
 
-            storeRequest.onsuccess = (e) => {
-      
-              let cachedData = e.target.result;
-        
-              if (
-                !cachedData
-              ) {
-                reject();
-              }
-        
-              if (
-                cachedData
-              ) {
-  
-                resolve(cachedData);
-              }
-            };
         
-            storeRequest.onerror = reject
-          } catch (error) {
-            reject();
+        let isCachedValid = true;
+
+        let cachedData = await this.storeManager.get(id);
+
+
+        try {
+
+          if (chunkHashesList.length < cachedData.hashes.length) throw new Error;
+
+          for (let hash of cachedData.hashes) {
+            if (
+              chunkHashesList.indexOf(hash) != cachedData.hashes.indexOf(hash)
+            ) isCachedValid = false;
           }
-        });
+        } catch (error) {
+          isCachedValid = false;
+        }
 
-        self.requestCache.set(id, pr);
 
-        await pr;
 
-        return pr;
 
-      } catch(e) {
-        let reqPrms = this.dataService.getChunk(app_id, id);
 
-        this.requestCache.set(id, reqPrms);
+        if (
+          !isCachedValid
+        ) {
+          // todo reload all data
+        }
 
-        let res = await reqPrms;
 
-        this.putChunk(id, res);
-  
-        return reqPrms;
+
+        let newChunkHashes = [];
+        let newChunks = [];
+
+
+
+        if (
+          chunkHashesList.length > cachedData.hashes.length
+        ) {
+          newChunkHashes = chunkHashesList.slice(cachedData.hashes.length);
+        }
+
+        if (
+          !isCachedValid
+        ) {
+          newChunkHashes = chunkHashesList;
+        }
+
+        if (
+          newChunkHashes.length > 0
+        ) {
+          const requests = newChunkHashes.map(hash => this.dataService.getChunk(id, hash));
+      
+          newChunks = await Promise.all(requests);
+        }
+
+        let mergedData;
+        if (
+          !isCachedValid
+        ) {
+          mergedData = await this.gudhub.util.mergeChunks([
+            // cachedData.mergedData,
+            ...newChunks,
+          ]);
+        }
+
+        if (
+          isCachedValid
+        ) {
+          mergedData = await this.gudhub.util.mergeChunks([
+            cachedData.mergedData,
+            ...newChunks,
+          ]);
+        }
+
+
+        if (
+          newChunkHashes.length > 0
+        ) {
+          this.putMergedChunks(id, {hashes: chunkHashesList, mergedData: {items_list: mergedData}});
+        }
+
+        return {items_list: mergedData};
+      } catch (error) {
+
+        const requests = chunkHashesList.map(hash => this.dataService.getChunk(id, hash));
+    
+        const newChunks = await Promise.all(requests);
+
+
+        let mergedData = await this.gudhub.util.mergeChunks(newChunks);
+
+        this.putMergedChunks(id, {hashes: chunkHashesList, mergedData: {items_list: mergedData}});
+
+        return {items_list: mergedData};
       }
     }
 
-    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 putMergedChunks(id, data) {
+      return this.storeManager.put(id, data);
     }
 }

package/GUDHUB/DataService/IndexedDB/IndexedDBService.js

@@ -1,9 +1,173 @@
-export class IndexedDBService {
-    constructor(conf) {
-        this.store = conf.store;
-        this.dbName = conf.dbName;
-        this.dbVersion = conf.dbVersion;
+import { appsConf } from "./appDataConf.js";
+import { chunksConf } from "./chunkDataConf.js";
+import { dbName, dbVersion } from "./consts.js";
+import { chunksMergeConf } from "./storeManagerConf/chunkCacheStoreManagerConf.js";
 
-        this.requestCache = new Map; // id -> promise
+
+
+export class StoreBackend { }
+
+
+export class IndexedDBManager extends StoreBackend {
+  constructor(
+    dbName,
+    storeNameList,
+  ) {
+    super();
+
+    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.storeNameList = storeNameList;
+
+    IndexedDBManager.dbNameToInstanceMap.set(dbName, this);
+  }
+
+  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;
+  }
+
+  async openDB() {
+    if (this.db) return this.db;
+
+    let resolver, rejecter;
+
+    let dbPrms = new Promise((resolve, reject) => {
+      resolver = resolve;
+      rejecter = reject;
+    });
+
+    for (let storeName of this.storeNameList) {
+      await this.checkAndCreateStore(storeName);
+    }
+
+    let self = this;
+
+    const request = indexedDB.open(this.dbName);
+
+    request.onsuccess = (event) => {
+      self.db = event.target.result;
+      resolver(this.db);
+    };
+
+    request.onerror = rejecter;
+
+    return dbPrms;
+  }
+
+  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;
+  //   }
+  // }
+}
+
+
+export const indexedDBStoreBackendSingleton = new IndexedDBManager(
+  dbName,
+  [
+    appsConf.store,
+    chunksConf.store,
+    chunksMergeConf.store,
+  ],
+);

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

@@ -0,0 +1,97 @@
+export class BaseStoreManager {
+  constructor(storeBackend, storeName) {
+    this.storeBackend = storeBackend;
+    this.storeName = storeName;
+  }
+
+  async addItem(id, data) {
+    return new Promise(async (resolve, reject) => {
+
+      this.storeBackend.executeOperation(this.storeName, (store) => {
+        const request = store.add(data, id);
+
+        request.onsuccess = resolve;
+        request.onerror = reject;
+      });
+
+    });
+  }
+
+  async putItem(id, data) {
+    return new Promise(async (resolve, reject) => {
+
+      this.storeBackend.executeOperation(this.storeName, (store) => {
+        const request = store.put(data, id);
+
+        request.onsuccess = resolve;
+        request.onerror = reject;
+      });
+
+    });
+  }
+
+  async hasItem(id) {
+    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;
+    }
+  }
+
+  async getItem(id) {
+    return new Promise(async (resolve, reject) => {
+
+      this.storeBackend.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.storeBackend.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.storeBackend.executeOperation(this.storeName, (store) => {
+        const request = store.delete(id);
+
+        request.onsuccess = resolve;
+        request.onerror = reject;
+      });
+
+    });
+  }
+}

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

@@ -0,0 +1,77 @@
+import { appsConf } from "../appDataConf.js";
+import { chunksConf } from "../chunkDataConf.js";
+import { indexedDBStoreBackendSingleton } from "../IndexedDBService.js";
+import { chunksMergeConf } from "../storeManagerConf/chunkCacheStoreManagerConf.js";
+import { BaseStoreManager } from "./BaseStoreManager.js";
+
+export class AppStoreManager extends BaseStoreManager {
+  constructor() {
+    super(indexedDBStoreBackendSingleton, appsConf.store);
+  }
+
+  async getApp(id) {
+    return this.getItem(id);
+  }
+
+  async addApp(id, data) {
+    return this.addItem(id, data);
+  }
+
+  async putApp(id, data) {
+    return this.putItem(id, data);
+  }
+
+  async hasApp(id) {
+    return this.hasItem(id);
+  }
+
+  async deleteApp(id) {
+    return this.deleteItem(id);
+  }
+}
+
+export class ChunksStoreManager extends BaseStoreManager {
+  constructor() {
+    super(indexedDBStoreBackendSingleton, chunksConf.store);
+  }
+
+
+  async getChunk(id) {
+    return this.getItem(id);
+  }
+
+  async addChunk(id, chunk) {
+    return this.addItem(id, chunk);
+  }
+
+  async putChunk(id, chunk) {
+    return this.putItem(id, chunk);
+  }
+
+  async deleteChunk(id) {
+    return this.deleteItem(id);
+  }
+}
+
+export class MergedChunksStoreManager extends BaseStoreManager {
+  constructor() {
+    super(indexedDBStoreBackendSingleton, chunksMergeConf.store);
+  }
+
+  async get(id) {
+    return this.getItem(id);
+  }
+
+  async add(id, chunk) {
+    return this.addItem(id, chunk);
+  }
+
+  //TODO update here ok?
+  async put(id, chunk) {
+    return this.putItem(id, chunk);
+  }
+
+  async delete(id) {
+    return this.deleteItem(id);
+  }
+}

package/GUDHUB/DataService/IndexedDB/appDataConf.js

@@ -1,7 +1,10 @@
-import { dbName, dbVersion } from "./consts.js";
+// import { dbName } from "./consts.js";
+
+
+// move to folder also remove chunksConf
 
 export const appsConf = {
-    dbName,
-    dbVersion,
+    // dbName,
+    // dbVersion,
     store: 'apps',
 };