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

package/GUDHUB/DataService/IndexedDB/IndexedDBAppService.js

@@ -1,175 +1,29 @@
 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 { 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";
 
 
+// TODO remove query parameters and check build success
 import AppRequestWorkerScript from '../../../dist/PARCEL_APP_REQUEST_WORKER_FILENAME.js?worker&inline';
 
-//this should be global in project
-// class IndexedDBFacade extends CacheService {
 
-// }
 
-
-
-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;
-    }
-  }
+export let WORKER_EVENTS = {
+  INIT: 1,
+  REQUEST_APP: 2,
+  PROCESS_DATA: 3,
+  DECLINE_PROCESS_DATA_REQUEST: 4,
 }
 
-
-
-//todo андрей сказал чанки два раза грузятся
-//при первой загрузке когда нет бд ничего не отображается
-//андрей предлагает грохать бд если проблемы со сторами
-
-
-// может поменять имя на StoreAppService???? потому что я уже сделал абстракцию
-
+// old class for worker. Contains useful code therefore isnt removed
 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 indexDBAppStoreManager = new AppStoreManager;
+      this.dataService = new AppHttpService(req, null, gudhub);
 
       this.requestCache = new Map; // id -> promise ///TODO seems irrelevant to class IndexedDBManager (could be renamed to Facade already)
 
@@ -185,7 +39,7 @@ export class IndexedDBAppServiceForWorker extends AppDataService {
 
 
       //TODO objectAssignWithOverride here too?
-      // this.dbManager = new IndexedDBManager('myDatabase', 'appsStore');
+      // this.storeBackend = new IndexedDBManager('myDatabase', 'appsStore');
 
 
 
@@ -213,7 +67,7 @@ export class IndexedDBAppServiceForWorker extends AppDataService {
     static [Symbol.hasInstance](instance) {
       try {
         if (instance instanceof IndexedDBAppServiceForWorker) 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;
@@ -433,83 +287,28 @@ export class IndexedDBAppServiceForWorker extends AppDataService {
       return pr;
     }
 
-    async getCached(id) {
-
-      return this.storeManager.getApp(id); //TODO investigate method name
 
+    async has(id) {
 
-      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);
+      try {
         
-          const storeRequest = store.get(id);
+        return this.storeManager.hasApp(id);
+      } catch (error) {
+        // debugger
+      }
+    }
 
-          storeRequest.onsuccess = (e) => {
-    
-            let cachedData = e.target.result;
-      
-            if (
-              !cachedData
-            ) {
-              reject();
-            }
-      
-            if (
-              cachedData
-            ) {
-              resolve(cachedData);
-            }
-          };
-      
-          storeRequest.onerror = reject;
-        } catch (error) {
-          reject();
-        }
-      });
-    
-      return pr;
+    async getCached(id) {
+      return this.storeManager.getApp(id);
     }
 
     async putApp(id, data) {
       return this.storeManager.putApp(id, data);
-
-      // try {        
-      //   await this.openDatabase();
-
-      //   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);
-    //     };
-    //   });
-    // }
 }
 
 
+// this class means work directly with indexeddb without worker
 export class IndexedDBAppService extends AppDataService {
   constructor(req, conf, gudhub) {
     super(req, conf, gudhub);
@@ -564,7 +363,7 @@ export class IndexedDBAppService extends AppDataService {
     // new Worker(new URL('./worker.js', import.meta.url));
 
 
-    this.appRequestAndProcessWorker.postMessage({ type: 'init', gudhubSerialized: this.gudhub.serialized });
+    this.appRequestAndProcessWorker.postMessage({ type: WORKER_EVENTS.INIT, gudhubSerialized: this.gudhub.serialized });
 
 
     let self = this;
@@ -585,7 +384,7 @@ export class IndexedDBAppService extends AppDataService {
 
 
       if (
-        e.data.type == 'requestApp'
+        e.data.type == WORKER_EVENTS.REQUEST_APP
       ) {
 
         if (
@@ -605,7 +404,7 @@ export class IndexedDBAppService extends AppDataService {
       // todo check this for new code
       // todo outdated code, to remove
       if (
-        e.data.type == 'processData'
+        e.data.type == WORKER_EVENTS.PROCESS_DATA
       ) {
       // if (id == e.data.id) {
         self.gudhub.itemProcessor.handleDiff(e.data.id, e.data.compareRes);
@@ -651,6 +450,13 @@ export class IndexedDBAppService extends AppDataService {
     //todo worker pool?
 
 
+    if (
+      this.isWithCache()
+    ) {
+      // move here storeManager
+      //TODO store could be with different implementations - indexeddb, cacheapi, others
+    }
+
     this.storeManager = new AppStoreManager;
 
     // objectAssignWithOverride(this, indexDBService);
@@ -661,7 +467,7 @@ export class IndexedDBAppService extends AppDataService {
   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
+      // if (instance instanceof IndexedDBService) return true; //TODO requires multiple inheritance, thhink how to overcome it
       return false;
     } catch (error) {
       return false;
@@ -673,7 +479,7 @@ export class IndexedDBAppService extends AppDataService {
 
 
   isWithCache() {
-    return false; //doesnt use indexeddb
+    return true;
   }
 
   async getApp(id) {//TODO -> get?
@@ -685,9 +491,11 @@ export class IndexedDBAppService extends AppDataService {
 
     let hasId = await this.has(id);
 
+    hasId = false;
+
 
     if (
-      false
+      hasId
     ) {
 
       // let promiseObject = Promise.
@@ -712,7 +520,7 @@ export class IndexedDBAppService extends AppDataService {
       // 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 });
+      this.appRequestAndProcessWorker.postMessage({ type: WORKER_EVENTS.PROCESS_DATA, id: id });
 
       return getFromDBPrms;
     } else {
@@ -725,8 +533,7 @@ export class IndexedDBAppService extends AppDataService {
 
       this.requestCache.set(id, prms);
 
-      //todo define types as constants
-      this.appRequestAndProcessWorker.postMessage({ type: 'requestApp', id: id });
+      this.appRequestAndProcessWorker.postMessage({ type: WORKER_EVENTS.REQUEST_APP, id: id });
 
 
 
@@ -835,49 +642,203 @@ export class IndexedDBAppService extends AppDataService {
     } catch (error) {
       debugger
     }
+  }
 
-    // try {
-    //   let cached = await this.getCached(id);
+  async putApp(id, data) {
+    return this.storeManager.putApp(id, data);
+  }
+}
 
-    //   if (!cached) return false;
+export class AppHttpWorkerService extends AppDataService {
+  constructor(req, conf, gudhub) {
+    super(req, conf, gudhub);
 
-    //   return true;
-    // } catch(e) {
-    //   //todo check error type and then rethrow maybe here
+    this.dataService = new AppHttpService(req, null, gudhub);
 
-    //   return false;
-    // }
+    this.requestCache = new Map; // id -> promise ///TODO seems irrelevant to class IndexedDBManager (could be renamed to Facade already)
+
+
+    this.gudhub = gudhub;
   }
 
-  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);
+  isWithCache() {
+    return false;
+  }
 
-    //   store.put(data, id);
-    // } catch (error) {
+  async getAppWithoutProcessing(id) {
+    let data = await this.dataService.getAppWithoutProcessing(id);
 
-    // }
+    await this.putApp(id, data);
+
+    return data;
+  }
+
+  async getApp(id) {
+    if (this.requestCache.has(id)) return this.requestCache.get(id);
+
+
+    let resolver, rejecter;
+
+    let prms = new Promise((resolve, reject) => {
+      resolver = resolve;
+      rejecter = reject;
+    });
+
+
+    this.requestCache.set(id, prms);
+
+
+    let data = await this.dataService.getAppWithoutProcessing(id);
+    let processedData = await this.processRequestedApp(id, data);
+
+    resolver(processedData);
+
+
+    return processedData;
+  }
+
+  async has(id) {
+    return false;
+  }
+
+  async getCached(id) {
+    throw new Error;
+  }
+
+  async putApp(id, data) {
+    throw new Error;
+  }
+}
+
+
+// this means works with indexeddb and http from worker env
+export class AppIndexedDBWorkerService extends AppDataService {
+  // todo set appropriate class from config !!!!!!!!!! this or  AppHttpWorkerService
+}
+
+export class AppThroughWebWorkerService extends AppDataService {
+  constructor(req, conf, gudhub) {
+    super(req, conf, gudhub);
+
+    this.dataService = new AppHttpService(req, conf, gudhub);
+
+    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
+
+
+    //todo worker pool?
+    this.appRequestAndProcessWorker = new AppRequestWorkerScript;
+
+
+
+    this.appRequestAndProcessWorker.postMessage({ type: WORKER_EVENTS.INIT, gudhubSerialized: this.gudhub.serialized });
+
+
+    let self = this;
+    this.appRequestAndProcessWorker.onerror = function(e) {
+      // self.appRequestAndProcessWorker.terminate();
+      //   // worker.terminate();
+      // console.error('Error in worker:', e);
+    };
+
+  
+    this.appRequestAndProcessWorker.onmessage = function(e) {
+
+      if (
+        e.data.type == WORKER_EVENTS.REQUEST_APP
+      ) {
+
+        if (
+          self.resolveFnMap.has(e.data.id)
+        ) {
+          let resolver = self.resolveFnMap.get(e.data.id);
+  
+          resolver(e.data.data);
+        }
+      }
+
+      if (
+        e.data.type == WORKER_EVENTS.PROCESS_DATA
+      ) {
+        self.gudhub.itemProcessor.handleDiff(e.data.id, e.data.compareRes);
+
+
+        if (
+          e.data.viewListChanged ||
+          e.data.fieldListChanged
+        ) {
+          self.gudhub.appProcessor.updateAppFieldsAndViews(e.data.newVersion);
+        }
+      }
+    };
+  
+
+    if (
+      this.isWithCache()
+    ) {
+      // return false;
+      // move here storeManager
+      //TODO store could be with different implementations - indexeddb, cacheapi, others
+    }
+
+    this.storeManager = 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;
+    }
+  }
+
+  isWithCache() {
+    return false;
+  }
+
+  //TODO -> rename to get ? Also should be for all derived classes and class tree
+  async getApp(id) {
+    if (this.requestCache.has(id)) return this.requestCache.get(id); // по этому коду есть вопрос - вызовы getApp  кешируются выше и тогда выходит возвращается старая версия?
+
+    let prms = new Promise((resolve, reject) => {
+      self.resolveFnMap.set(id, resolve);
+    });
+
+
+    this.requestCache.set(id, prms);
+
+    this.appRequestAndProcessWorker.postMessage({ type: WORKER_EVENTS.REQUEST_APP, id: id });
+
+
+
+    return prms;
   }
 
-  //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);
-  //     };
-  //   });
-  // }
+  async getCached(id) {//TODO -> getFromStore?
+    return this.storeManager.getApp(id); //TODO investigate method name
+  }
+
+  async has(id) {
+
+    try {
+      
+      return this.storeManager.hasApp(id);
+    } catch (error) {
+      debugger
+    }
+  }
+
+  async putApp(id, data) {
+    return this.storeManager.putApp(id, data);
+  }
 }