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

package/GUDHUB/DataService/IndexedDB/appRequestWorker.js

@@ -0,0 +1,163 @@
+
+import { appDataServiceConf, AppDataServiceForWorker, ChunkDataServiceForWorker } from "../export.js";
+import { WORKER_EVENTS } 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";
+import { GudHubForAppRequestWorker } from "../../gudhubAppRequestWorker.js";
+
+
+let gudhub = {};
+let appDataService = {};
+let chunkDataService = {};
+
+
+globalThis.onmessage = async function(e) {
+  if (
+    e.data.type === WORKER_EVENTS.INIT
+  ) {
+    e.data.gudhubSerialized.options.initWebsocket = false;
+
+    gudhub = new GudHubForAppRequestWorker(e.data.gudhubSerialized.authKey, e.data.gudhubSerialized.options);
+    appDataService = new AppDataServiceForWorker(gudhub.req, appsConf, gudhub);
+    chunkDataService = new ChunkDataServiceForWorker(gudhub.req, chunksMergeConf, gudhub);
+  }
+
+  if (
+    e.data.type == WORKER_EVENTS.PROCESS_DATA
+  ) {
+
+
+    //TODO тут может прийти запрос и данные не кешируются. тогда нужно вернуть пустые данные и как-то убрать в пендинге запрос или промис в клиентском коде !!!!!!!!!!
+    //TODO pass parameter is cached version exist
+
+
+
+    if (
+      !e.data.usedCachedDataVersion
+    ) {
+      this.postMessage({id: e.data.id, type: WORKER_EVENTS.DECLINE_PROCESS_DATA_REQUEST});
+      return;
+    }
+
+
+    //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 == WORKER_EVENTS.REQUEST_APP
+  ) {
+    try {
+    let data = await gudhub.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});
+    } catch (error) {
+
+      // todo reply with null or use DECLINE_PROCESS_DATA_REQUEST because outer code waits for response anyway and uses data structures for waiting
+    }
+
+  }
+};

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,2 @@
 export const dbName = "gudhub";
-export const dbVersion = 7;
+// export const dbVersion = 7;

package/GUDHUB/DataService/IndexedDB/init.js

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

package/GUDHUB/DataService/export.js

@@ -1,6 +1,6 @@
-import { cache_app_requests, cache_chunk_requests } from "../config.js";
-import { IS_WEB } from "../consts.js";
-import { IndexedDBAppService } from "./IndexedDB/IndexedDBAppService.js";
+import { cache_app_requests, cache_chunk_requests, useWorkerToProcessRequestsData } from "../config.js";
+import { IS_BROWSER } from "../consts.js";
+import { AppHttpWorkerService, AppIndexedDBWorkerService, AppThroughWebWorkerService, IndexedDBAppService, IndexedDBAppServiceForWorker } from "./IndexedDB/IndexedDBAppService.js";
 import { IndexedDBChunkService } from "./IndexedDB/IndexedDBChunkService.js";
 import { appsConf } from "./IndexedDB/appDataConf.js";
 import { chunksConf } from "./IndexedDB/chunkDataConf.js";
@@ -8,7 +8,10 @@ import { AppHttpService } from "./httpService/AppHttpService.js";
 import { ChunkHttpService } from "./httpService/ChunkHttpService.js";
 
 
-import "./IndexedDB/init.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;
@@ -16,33 +19,85 @@ let ChunkDataService;
 let appDataServiceConf;
 let chunkDataServiceConf;
 
+if (
+    IS_BROWSER &&
+    cache_app_requests &&
+    !useWorkerToProcessRequestsData
+) {
+    AppDataService = IndexedDBAppService;
+    appDataServiceConf = appsConf;
+}
+
+
+if (
+    IS_BROWSER &&
+    useWorkerToProcessRequestsData &&
+    !cache_app_requests
+) {
+    AppDataService = AppThroughWebWorkerService;
+    appDataServiceConf = appsConf; // todo seems isnt required for picked class
+}
+
+
+if (
+    !IS_BROWSER
+) {
+    AppDataService = AppHttpService;
+}
+
+
+if (
+    useWorkerToProcessRequestsData &&
+    cache_app_requests
+) {
+    throw new Error;
+    // not implemented
+}
+
 
 if (
-    IS_WEB &&
-    cache_chunk_requests
+    IS_BROWSER &&
+    cache_chunk_requests &&
+    !useWorkerToProcessRequestsData
 ) {
     ChunkDataService = IndexedDBChunkService;
     chunkDataServiceConf = chunksConf;
+}
 
-} else {
-    ChunkDataService = ChunkHttpService;
+if (
+    IS_BROWSER &&
+    cache_chunk_requests &&
+    useWorkerToProcessRequestsData
+) {
+    // here should be http instead, but should be revised variable ChunkDataService usage
+    ChunkDataService = IndexedDBChunkService;
+    chunkDataServiceConf = chunksConf;
 }
 
 
 if (
-    IS_WEB &&
-    cache_app_requests
+    !IS_BROWSER
 ) {
-    AppDataService = IndexedDBAppService;
-    appDataServiceConf = appsConf;
-} else {
-    AppDataService = AppHttpService;
+    ChunkDataService = ChunkHttpService;
 }
 
 
+let AppDataServiceForWorker = AppHttpWorkerService;
+let ChunkDataServiceForWorker = IndexedDBChunkService;
+
+
+if (
+    useWorkerToProcessRequestsData &&
+    !cache_app_requests
+) {
+    AppDataServiceForWorker = AppHttpWorkerService;
+}
+
 export {
     AppDataService,
     ChunkDataService,
     appDataServiceConf,
     chunkDataServiceConf,
+    AppDataServiceForWorker,
+    ChunkDataServiceForWorker,
 };

package/GUDHUB/DataService/httpService/AppHttpService.js

@@ -5,22 +5,30 @@ import { HttpService } from "./HttpService.js";
 
 export class AppHttpService extends AppDataService {
     constructor(req, conf, gudhub) {
-      super();
+      super(req, conf, gudhub);
   
       this.appApi = new AppAPI(req);
 
-      let indexDBService = new HttpService(conf);
+      let httpService = new HttpService(conf);
     
-      objectAssignWithOverride(this, indexDBService);
+      objectAssignWithOverride(this, httpService);
     }
 
 
+    // TODO getApp -> getAppAndProcessData
     async getApp(id) {
+        let sentData = await this.appApi.getApp(id);
+        return this.processRequestedApp(id, sentData);
+    }
+
+
+    // TODO -> getApp
+    async getAppWithoutProcessing(id) {
         return this.appApi.getApp(id);
     }
 
     async putApp(id, app) {
-
+        // do nothing
     }
   
     static [Symbol.hasInstance](instance) {
@@ -32,4 +40,4 @@ export class AppHttpService extends AppDataService {
             return false;
         }
     }
-}
+};

package/GUDHUB/DataService/httpService/ChunkHttpService.js

@@ -4,33 +4,48 @@ import { objectAssignWithOverride } from "../utils.js";
 import { HttpService } from "./HttpService.js";
 
 export class ChunkHttpService extends ChunkDataService {
-    constructor(req, conf) {
-      super();
+  constructor(req, conf) {
+    super();
+
+    this.chunkApi = new ChunkAPI(req);
+
+    let httpService = new HttpService(conf);
   
-      this.chunkApi = new ChunkAPI(req);
+    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) {
+    // implementation doesnt have cached
+  }
 
-      let indexDBService = new HttpService(conf);
+  getMergedChunkForIDList(id, chunkHashesList) {
     
-      objectAssignWithOverride(this, indexDBService);
-    }
-  
-    async getChunk(app_id, id) {
-      return this.chunkApi.getChunk(app_id, id);
-    }
-  
-  
-    putChunk() {
-      //do nothing
-    }
-
-
-    static [Symbol.hasInstance](instance) {
-        try {
-          if (instance instanceof ChunkHttpService) return true;
-          if (instance instanceof HttpService) return true; //TODO requires multiple inheritance, thhink how to overcome it
-          return false;
-        } catch (error) {
-          return false;
-        }
-    }
+  }
+
+
+  putChunk() {
+    //do nothing
+  }
+
+
+  static [Symbol.hasInstance](instance) {
+      try {
+        if (instance instanceof ChunkHttpService) return true;
+        if (instance instanceof HttpService) return true; //TODO requires multiple inheritance, thhink how to overcome it
+        return false;
+      } catch (error) {
+        return false;
+      }
+  }
 }

package/GUDHUB/DataService/utils.js

@@ -1,34 +1,34 @@
 
 export let objectAssignWithoutOverride = (target, ...sourceList) => {
-    for (let source of sourceList) {
-      if (!source) continue;
-      for(let key of Object.keys(source)) {//this doesnt iterate over class like source properties
-        if (!(key in target)) {//checks own and inherited keys, works fine also for class prototypes and instances
-          const desc = Object.getOwnPropertyDescriptor(source, key);
-          if (desc.enumerable) Object.defineProperty(target, key, desc);
-        }
-      }
-    }
-  };
-  
-  export let objectAssignWithOverride = (target, ...sourceList) => {
-    for (let source of sourceList) {
-      if (!source) continue;
-      for(let key of Object.keys(source)) {//this doesnt iterate over class like source properties
+  for (let source of sourceList) {
+    if (!source) continue;
+    for(let key of Object.keys(source)) {//this doesnt iterate over class like source properties
+      if (!(key in target)) {//checks own and inherited keys, works fine also for class prototypes and instances
         const desc = Object.getOwnPropertyDescriptor(source, key);
         if (desc.enumerable) Object.defineProperty(target, key, desc);
       }
     }
-  };
-  
-  
-  
-  export let checkInstanceModifier = (target, ...sourceList) => {
-    for (let source of sourceList) {
-      if (!source) continue;
-      for(let key of Object.keys(source)) {//this doesnt iterate over class like source properties
-        const desc = Object.getOwnPropertyDescriptor(source, key);
-        if (desc.enumerable) Object.defineProperty(target, key, desc);
-      }
+  }
+};
+
+export let objectAssignWithOverride = (target, ...sourceList) => {
+  for (let source of sourceList) {
+    if (!source) continue;
+    for(let key of Object.keys(source)) {//this doesnt iterate over class like source properties
+      const desc = Object.getOwnPropertyDescriptor(source, key);
+      if (desc.enumerable) Object.defineProperty(target, key, desc);
+    }
+  }
+};
+
+
+
+export let checkInstanceModifier = (target, ...sourceList) => {
+  for (let source of sourceList) {
+    if (!source) continue;
+    for(let key of Object.keys(source)) {//this doesnt iterate over class like source properties
+      const desc = Object.getOwnPropertyDescriptor(source, key);
+      if (desc.enumerable) Object.defineProperty(target, key, desc);
     }
-  };
+  }
+};

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;