@gudhub/core 1.2.4-beta.3 → 1.2.4-beta.32

package/GUDHUB/DataService/IndexedDB/appRequestWorker.js

@@ -0,0 +1,225 @@
+
+import { appDataServiceConf } from "../export.js";
+import { GudHub } from "../../gudhub.js";
+import { IndexedDBAppServiceForWorker } from "../IndexedDB/IndexedDBAppService.js";
+import { appsConf } from "../IndexedDB/appDataConf.js";
+import { IndexedDBChunkService } from "./IndexedDBChunkService.js";
+import { chunksConf } from "./chunkDataConf.js";
+import { chunksMergeConf } from "./storeManagerConf/chunkCacheStoreManagerConf.js";
+
+
+
+let gudhub = {};
+let appDataService = {};
+let chunkDataService = {};
+
+
+
+//TODO also ChunkDataService !!!!!!!!!!!!!!!!!!!!!!!
+
+
+self.onmessage = async function(e) {
+  if (e.data.type === 'init') {
+
+
+    e.data.gudhubSerialized.options.initWebsocket = false;
+
+    gudhub = new GudHub(e.data.gudhubSerialized.authKey, e.data.gudhubSerialized.options);
+    appDataService = new IndexedDBAppServiceForWorker(gudhub.req, appsConf, gudhub);
+    chunkDataService = new IndexedDBChunkService(gudhub.req, chunksMergeConf, gudhub);
+
+
+  }
+
+  if (e.data.type === 'processData') {
+
+
+
+        //todo cached could not exist !!!!!!!!!!!!!!!!!!!
+
+    let cached = await appDataService.getCached(e.data.id); // merge ?
+
+
+    let cachedChunksList = cached.chunks;
+
+
+    let nextVersion = await appDataService.getAppWithoutProcessing(e.data.id);
+
+
+    let isMergedChunkUpdated = true;
+
+
+    if (
+      cachedChunksList.length != nextVersion.chunks.length
+    ) isMergedChunkUpdated = false;
+
+
+    //TODO here old chunks should be exactly with ids that came from app get request
+    if (
+      nextVersion.chunks.some(entry => !cachedChunksList.includes(entry))
+    ) isMergedChunkUpdated = false;
+
+
+    if (
+      !isMergedChunkUpdated
+    ) {
+
+      // TODO this is repetitive operation for getCached, maybe put all code in process or in getCached
+
+      let res = await chunkDataService.getCachedMergedChunk(e.data.id, cached.chunks);
+
+      // if (!res) res = [];
+
+
+      // // TODO check that res always exists
+
+
+      if (
+          res
+      ) {
+          cached.items_list = await gudhub.util.mergeChunks([
+              // cachedApp,
+              res,
+              cached,
+          ]);
+      } else {
+          // sentData.items_list = await this.gudhub.util.mergeChunks([
+          //     cachedApp,
+          //     sentData,
+          // ]);
+      }
+
+      // nextVersion = await appDataService.getAppWithSpecificChunksList(e.data.id, newChunksList); //todo check that here most recent always
+      nextVersion = await appDataService.getApp(e.data.id); //todo check that here most recent always
+
+
+      //TODO тут достаточно сравнить новые чанки+апп и закешированный апп, тогда будет сгенерирована вся инфа о новых данных
+
+
+      // return;
+    }
+
+
+
+
+
+
+
+
+    // let comparison = gudhub.compareItems(cached.items_list, newVersion.items_list);
+    let comparison = gudhub.compareItems(nextVersion.items_list, cached.items_list);
+
+
+    // async handleAppChange(id, prevVersion, nextVersion) {
+    let flag1 = gudhub.util.areViewListsEqual(cached.views_list, nextVersion.views_list);
+    let flag2 = gudhub.util.areFieldListsEqual(cached.field_list, nextVersion.field_list);
+
+    // if (
+    //   res1 ||
+    //   res2
+    // ) {
+    //   this.updateAppFieldsAndViews({id, views_list: nextVersion.views_list, field_list: nextVersion.field_list});
+    // }
+    // }
+
+
+
+    this.postMessage({
+      id: e.data.id, 
+      compareRes: comparison, 
+      newVersion: nextVersion, 
+      type: e.data.type, 
+      viewListChanged: flag1,
+      fieldListChanged: flag2,
+    });
+
+
+
+
+    /// todo process data merge and then call merge and compare and then return from here for example event to update
+
+
+
+    // also dont forget that main thread also uses AppDataService !!!!!!!!!!!!!!!!!! make temporarile a separate class for it maybe
+
+}
+
+
+  if (
+    e.data.type === 'requestApp'
+  ) {
+
+    // //todo cached could not exist !!!!!!!!!!!!!!!!!!!
+
+    // let cached = await appDataService.getCached(e.data.id); // merge ?
+
+
+    // let cachedChunksList = cached.chunks;
+
+
+    // let nextVersion = await appDataService.getAppWithoutProcessing(e.data.id);
+
+
+    // let isMergedChunkUpdated = true;
+
+
+    // if (
+    //   cachedChunksList.length != nextVersion.chunks.length
+    // ) isMergedChunkUpdated = false;
+
+
+    // //TODO here old chunks should be exactly with ids that came from app get request
+    // if (
+    //   nextVersion.chunks.some(entry => !cachedChunksList.includes(entry))
+    // ) isMergedChunkUpdated = false;
+
+
+    // if (
+    //   !isMergedChunkUpdated
+    // ) {
+
+    //   // TODO this is repetitive operation for getCached, maybe put all code in process or in getCached
+
+    //   let res = await chunkDataService.getCachedMergedChunk(e.data.id, cached.chunks);
+
+    //   // if (!res) res = [];
+
+
+    //   // // TODO check that res always exists
+
+
+    //   if (
+    //       res
+    //   ) {
+    //       cached.items_list = await gudhub.util.mergeChunks([
+    //           // cachedApp,
+    //           res,
+    //           cached,
+    //       ]);
+    //   } else {
+    //       // sentData.items_list = await this.gudhub.util.mergeChunks([
+    //       //     cachedApp,
+    //       //     sentData,
+    //       // ]);
+    //   }
+
+    //   // nextVersion = await appDataService.getAppWithSpecificChunksList(e.data.id, newChunksList); //todo check that here most recent always
+    //   nextVersion = await appDataService.getApp(e.data.id); //todo check that here most recent always
+
+
+    //   //TODO тут достаточно сравнить новые чанки+апп и закешированный апп, тогда будет сгенерирована вся инфа о новых данных
+
+
+    //   // return;
+    // }
+
+    let data = await appDataService.getApp(e.data.id); //todo check process request method seems there i return cahced version not most recent data from server
+
+
+    this.postMessage({id: e.data.id, type: e.data.type, data});
+
+  }
+
+
+  // this.appRequestAndProcessWorker.postMessage({ type: 'requestApp', id: id });
+};

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

@@ -1,21 +1,22 @@
-import { IS_WEB } from "../../consts.js";
+import { IS_BROWSER, IS_WEB } from "../../consts.js";
 import { appsConf } from "./appDataConf.js";
 import { chunksConf } from "./chunkDataConf.js";
 import { dbName, dbVersion } from "./consts.js";
 
 
-if (
-    IS_WEB
-) {
-    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

@@ -1,5 +1,5 @@
 import { cache_app_requests, cache_chunk_requests } from "../config.js";
-import { IS_WEB } from "../consts.js";
+import { IS_BROWSER, IS_WEB } from "../consts.js";
 import { IndexedDBAppService } from "./IndexedDB/IndexedDBAppService.js";
 import { IndexedDBChunkService } from "./IndexedDB/IndexedDBChunkService.js";
 import { appsConf } from "./IndexedDB/appDataConf.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;
 
@@ -18,7 +21,7 @@ let chunkDataServiceConf;
 
 
 if (
-    IS_WEB &&
+    IS_BROWSER &&
     cache_chunk_requests
 ) {
     ChunkDataService = IndexedDBChunkService;
@@ -30,10 +33,10 @@ if (
 
 
 if (
-    IS_WEB &&
-    cache_app_requests
+    IS_BROWSER &&
+    cache_app_requests // todo here outdated approach
 ) {
-    AppDataService = IndexedDBAppService;
+    AppDataService = IndexedDBAppService; // here will be AppHttpService for browser too, check compatability. Checked. seems different code. IndexedDBAppService uses worker
     appDataServiceConf = appsConf;
 } else {
     AppDataService = AppHttpService;

package/GUDHUB/DataService/httpService/AppHttpService.js

@@ -1,26 +1,44 @@
 import { AppAPI } from "../../api/AppApi.js";
 import { AppDataService } from "../AppDataService.js";
+import { ChunkDataService } from "../export.js";
 import { objectAssignWithOverride } from "../utils.js";
 import { HttpService } from "./HttpService.js";
 
 export class AppHttpService extends AppDataService {
-    constructor(req, conf) {
-      super();
+    constructor(req, conf, gudhub) {
+      super(req, conf, gudhub);
   
       this.appApi = new AppAPI(req);
 
       let indexDBService = new HttpService(conf);
+
+
+    //   this.chunkDataService = new ChunkDataService; //TODO move to 
     
       objectAssignWithOverride(this, indexDBService);
     }
 
 
     async getApp(id) {
+        let sentData = await this.appApi.getApp(id);
+        return this.processRequestedApp(id, sentData); //TODO check is it ok to trigger change isnide method for AppHttpService
+    }
+
+    //TODO should be getApp and getAppAndProcessData - refactor whole code to use them
+
+
+
+
+    //TODO андрей говорил про то что там надо фильтровать айтемы удаленные, я так и не доделал
+
+
+
+    async getAppWithoutProcessing(id) {
         return this.appApi.getApp(id);
     }
 
     async putApp(id, app) {
-
+        // do nothing
     }
   
     static [Symbol.hasInstance](instance) {
@@ -32,4 +50,4 @@ export class AppHttpService extends AppDataService {
             return false;
         }
     }
-}
+};

package/GUDHUB/DataService/httpService/ChunkHttpService.js

@@ -9,14 +9,31 @@ export class ChunkHttpService extends ChunkDataService {
   
       this.chunkApi = new ChunkAPI(req);
 
-      let indexDBService = new HttpService(conf);
+      let httpService = new HttpService(conf);
     
-      objectAssignWithOverride(this, indexDBService);
+      objectAssignWithOverride(this, httpService);
     }
   
     async getChunk(app_id, id) {
       return this.chunkApi.getChunk(app_id, id);
     }
+
+    async getChunksForId(app_id) {
+      // maybe use app get api for now and return app.chunks from there
+
+      return []; // list of chunks
+    }
+
+
+    getCachedMergedChunk(id, chunkHashesList) {
+
+    }
+
+
+    //here
+    getMergedChunkForIDList(id, chunkHashesList) {
+      
+    }
   
   
     putChunk() {

package/GUDHUB/DataService/utils.js

@@ -31,4 +31,107 @@ export let objectAssignWithoutOverride = (target, ...sourceList) => {
         if (desc.enumerable) Object.defineProperty(target, key, desc);
       }
     }
-  };
+  };
+
+
+
+//   // Base classes
+// class IndexedDBMixin {
+//   constructor(dbName, version) {
+//       this.dbName = dbName;
+//       this.version = version;
+//       this.dbPromise = this.openConnection();
+//   }
+
+//   openConnection() {
+//       return new Promise((resolve, reject) => {
+//           const request = indexedDB.open(this.dbName, this.version);
+
+//           request.onupgradeneeded = (event) => {
+//               const db = event.target.result;
+//               if (!db.objectStoreNames.contains('storeName')) {
+//                   db.createObjectStore('storeName', { keyPath: 'id' });
+//               }
+//           };
+
+//           request.onsuccess = (event) => resolve(event.target.result);
+//           request.onerror = (event) => reject(event.target.error);
+//       });
+//   }
+
+//   async getDB() {
+//       return await this.dbPromise;
+//   }
+  
+//   async addRecord(storeName, record) {
+//       const db = await this.getDB();
+//       return new Promise((resolve, reject) => {
+//           const transaction = db.transaction(storeName, 'readwrite');
+//           const store = transaction.objectStore(storeName);
+//           const request = store.add(record);
+
+//           request.onsuccess = () => resolve(request.result);
+//           request.onerror = () => reject(request.error);
+//       });
+//   }
+
+//   async getRecord(storeName, key) {
+//       const db = await this.getDB();
+//       return new Promise((resolve, reject) => {
+//           const transaction = db.transaction(storeName, 'readonly');
+//           const store = transaction.objectStore(storeName);
+//           const request = store.get(key);
+
+//           request.onsuccess = () => resolve(request.result);
+//           request.onerror = () => reject(request.error);
+//       });
+//   }
+// }
+
+// class LoggingMixin {
+//   log(message) {
+//       console.log(message);
+//   }
+  
+//   error(message) {
+//       console.error(message);
+//   }
+// }
+
+// // Mixin function
+// function applyMixins(targetClass, baseClasses) {
+//   baseClasses.forEach(baseClass => {
+//       Object.getOwnPropertyDescriptors(baseClass.prototype).forEach(descriptor => {
+//           Object.defineProperty(targetClass.prototype, descriptor[0], descriptor[1]);
+//       });
+//   });
+// }
+
+// // Combined class
+// class EnhancedIndexedDB extends IndexedDBMixin {
+//   constructor(dbName, version) {
+//       super(dbName, version);
+//   }
+// }
+
+// // Apply mixins
+// applyMixins(EnhancedIndexedDB, [LoggingMixin]);
+
+// // Usage example
+// const dbFacade = new EnhancedIndexedDB('myDatabase', 1);
+
+// dbFacade.addRecord('storeName', { id: 1, name: 'Sample' })
+//   .then((id) => {
+//       dbFacade.log('Record added with id: ' + id);
+//   })
+//   .catch((error) => {
+//       dbFacade.error('Error adding record: ' + error);
+//   });
+
+// dbFacade.getRecord('storeName', 1)
+//   .then((record) => {
+//       dbFacade.log('Record retrieved: ' + JSON.stringify(record));
+//   })
+//   .catch((error) => {
+//       dbFacade.error('Error retrieving record: ' + error);
+//   });

package/GUDHUB/FileManager/FileManager.js

@@ -39,7 +39,7 @@ export class FileManager {
     }
   }
 
-  async updateFileFromStringApi(data, file_id, file_name, extension, format) {
+  async updateFileFromStringApi(data, file_id, file_name, extension, format, alt, title) {
     try {
       const fileObj = {
         file_name,
@@ -47,6 +47,8 @@ export class FileManager {
         file_id,
         format,
         source: data,
+        alt,
+        title
       };
 
       const file = await this.req.post({
@@ -198,13 +200,15 @@ async getFiles(app_id, filesId = []) {
     return file;
   }
 
-  async updateFileFromString(data, file_id, file_name, extension, format) {
+  async updateFileFromString(data, file_id, file_name, extension, format, alt, title) {
     const file = await this.updateFileFromStringApi(
       data,
       file_id,
       file_name,
       extension,
-      format
+      format,
+      alt,
+      title
     );
     this.updateFileInStorage(file_id, file.app_id, file);
     return file;

package/GUDHUB/GHConstructor/createAngularModuleInstance.js

@@ -1,5 +1,5 @@
 import axios from 'axios';
-import { IS_WEB } from './../consts.js';
+import { IS_BROWSER_MAIN_THREAD, IS_WEB } from './../consts.js';
 
 /*************** FAKE ANGULAR $Q ***************/
 // It's needed when we import angular code.
@@ -80,7 +80,7 @@ export default async function createAngularModuleInstance(gudhub, module_id, mod
         let angularModule;
         let importedClass;
 
-        if (IS_WEB) {
+        if (IS_BROWSER_MAIN_THREAD) {
 
             if(window.angular) {
 
@@ -290,7 +290,7 @@ export default async function createAngularModuleInstance(gudhub, module_id, mod
 
         // We need these methods in browser environment only
 
-        if (IS_WEB) {
+        if (IS_BROWSER_MAIN_THREAD) {
 
             //*************** EXTEND CONTROLLER ****************//
 

package/GUDHUB/GHConstructor/createClassInstance.js

@@ -1,5 +1,5 @@
 import axios from 'axios';
-import { IS_WEB } from './../consts.js';
+import { IS_BROWSER_MAIN_THREAD, IS_WEB } from './../consts.js';
 
 export default async function createClassInstance(gudhub, module_id, js_url, css_url, nodeWindow) {
 
@@ -14,7 +14,7 @@ export default async function createClassInstance(gudhub, module_id, js_url, css
         // Import module using dynamic import
 
         let downloadModule = (url) => {
-            if (!IS_WEB && !global.hasOwnProperty('window')) {
+            if (!IS_BROWSER_MAIN_THREAD && !global.hasOwnProperty('window')) {
                 global.window = proxy;
                 global.document = nodeWindow.document;
                 global.Element = nodeWindow.Element;
@@ -67,7 +67,7 @@ export default async function createClassInstance(gudhub, module_id, js_url, css
         // Check if there is url to css file of module
         // If true, and there is no css for this data type, than create link tag to this css in head
 
-        if (css_url && IS_WEB) {
+        if (css_url && IS_BROWSER_MAIN_THREAD) {
             const linkTag = document.createElement('link');
             linkTag.href = css_url;
             linkTag.setAttribute('data-module', module_id);

package/GUDHUB/ItemProcessor/ItemProcessor.js

@@ -118,6 +118,30 @@ export class ItemProcessor {
     return items;
   }
 
+  //here
+
+  /////
+  handleItemsChange(id, prevVersion, nextVersion) {
+    let compareRes = this.util.compareItems(prevVersion.items_list, nextVersion.items_list);
+
+    this.updateItemsInStorage(id, compareRes.diff_src_items);
+    this.addItemsToStorage(id, compareRes.new_src_items);
+  }
+
+
+  //
+  triggerItemsChange(id, compareRes) {
+    this.updateItemsInStorage(id, compareRes.diff_src_items);
+    this.addItemsToStorage(id, compareRes.new_src_items);
+  }
+
+  //
+  handleDiff(id, compare) {
+    this.updateItemsInStorage(id, compare.diff_src_items);
+    this.addItemsToStorage(id, compare.new_src_items);
+    this.deleteItemsFromStorage(id, compare.trash_src_items);
+  }
+
   async deleteItemsFromStorage(app_id, itemsForDelete = []) {
     const app = await this.appProcessor.getApp(app_id);
     if (app) {