@xuda.io/runtime-bundle 1.0.560 → 1.0.562

package/js/modules/xuda-db-adapter-module.mjs

@@ -8,12 +8,7 @@ export const init_module = async (e) => {
   _this.IS_DOCKER = e.IS_DOCKER;
   _this.IS_API_SERVER = e.IS_API_SERVER;
   _this.IS_PROCESS_SERVER = e.IS_PROCESS_SERVER;
-  if (
-    !_this.xuda_dbs_plugin &&
-    typeof _this.IS_DOCKER === "undefined" &&
-    typeof _this.IS_PROCESS_SERVER === "undefined" &&
-    typeof _this.IS_API_SERVER === "undefined"
-  ) {
+  if (!_this.xuda_dbs_plugin && typeof _this.IS_DOCKER === 'undefined' && typeof _this.IS_PROCESS_SERVER === 'undefined' && typeof _this.IS_API_SERVER === 'undefined') {
     await init_xuda_dbs_plugin(e.SESSION_ID);
   }
   _this.db_replication_store;
@@ -28,26 +23,15 @@ _db.save_data = async function (SESSION_ID, dsSessionP, keyP) {
   // const app_id = _this.SESSION_OBJ[SESSION_ID].app_id;
 
   var db_driver = await this.get_db_driver(SESSION_ID, dsSessionP);
-  if (db_driver === "pouchdb" && _this.glb.IS_WORKER) {
-    var callback_id = _this.func.utils.set_callback_queue(
-      SESSION_ID,
-      callbackP
-    );
-    var obj = _this.func.utils.clean_returned_datasource(
-      SESSION_ID,
-      dsSessionP
-    );
-    return _this.func.utils.post_back_to_client(
-      SESSION_ID,
-      "execute_local_sava_data",
-      _this.SESSION_OBJ[SESSION_ID].worker_id,
-      {
-        ds_obj: obj,
-        dsSessionP: dsSessionP,
-        keyP: keyP,
-        callback_id: callback_id,
-      }
-    );
+  if (db_driver === 'pouchdb' && _this.glb.IS_WORKER) {
+    var callback_id = _this.func.utils.set_callback_queue(SESSION_ID, callbackP);
+    var obj = _this.func.utils.clean_returned_datasource(SESSION_ID, dsSessionP);
+    return _this.func.utils.post_back_to_client(SESSION_ID, 'execute_local_sava_data', _this.SESSION_OBJ[SESSION_ID].worker_id, {
+      ds_obj: obj,
+      dsSessionP: dsSessionP,
+      keyP: keyP,
+      callback_id: callback_id,
+    });
   }
 
   _db.save_indicator(SESSION_ID, true);
@@ -60,36 +44,29 @@ _db.save_data = async function (SESSION_ID, dsSessionP, keyP) {
 
   if (!dataSourceTableId) {
     _db.save_indicator(SESSION_ID, false);
-    _this.func.utils.alerts.invoke(SESSION_ID, "system_msg", "SYS_MSG_0105"); //Table entry missing
+    _this.func.utils.alerts.invoke(SESSION_ID, 'system_msg', 'SYS_MSG_0105'); //Table entry missing
     return;
   }
 
   var db_driver = await _db.get_db_driver(SESSION_ID, dsSessionP);
 
-  let table_ret = await _this.func.utils.FILES_OBJ.get(
-    SESSION_ID,
-    dataSourceTableId
-  );
+  let table_ret = await _this.func.utils.FILES_OBJ.get(SESSION_ID, dataSourceTableId);
 
   if (!table_ret.tableIndexes || _.isEmpty(table_ret.tableIndexes)) {
     _db.save_indicator(SESSION_ID, false);
-    _this.func.utils.alerts.invoke(SESSION_ID, "system_msg", "SYS_MSG_0104"); //index missing
+    _this.func.utils.alerts.invoke(SESSION_ID, 'system_msg', 'SYS_MSG_0104'); //index missing
     return;
   }
 
   if (!_ds.data_feed.rows) {
-    return console.error("data_feed rows is empty");
+    return console.error('data_feed rows is empty');
   }
 
   const clean_virtual_fields = async function (table_id, data) {
     let table_obj = await func.utils.VIEWS_OBJ.get(SESSION_ID, table_id);
     var data_obj = {};
     for (const [key, val] of Object.entries(data)) {
-      const _tableFieldsObj = func.common.find_item_by_key(
-        table_obj.tableFields,
-        "field_id",
-        key
-      );
+      const _tableFieldsObj = func.common.find_item_by_key(table_obj.tableFields, 'field_id', key);
       if (_tableFieldsObj) {
         data_obj[key] = val;
       }
@@ -98,13 +75,9 @@ _db.save_data = async function (SESSION_ID, dsSessionP, keyP) {
   };
   let save_ret;
   // component
-  if (_view_obj.properties.menuType === "component") {
-    if (_view_obj?.properties?.rwMode !== "U") {
-      return _this.func.utils.alerts.invoke(
-        SESSION_ID,
-        "system_msg",
-        "SYS_MSG_0126"
-      ); //Program Read Only
+  if (_view_obj.properties.menuType === 'component') {
+    if (_view_obj?.properties?.rwMode !== 'U') {
+      return _this.func.utils.alerts.invoke(SESSION_ID, 'system_msg', 'SYS_MSG_0126'); //Program Read Only
     }
 
     // check if rows exist
@@ -114,25 +87,15 @@ _db.save_data = async function (SESSION_ID, dsSessionP, keyP) {
     let data = { prog_id: _ds.prog_id };
     if (_ds.data_feed.rows_added?.length) {
       if (!_view_obj?.properties?.allowCreate) {
-        _this.func.utils.alerts.invoke(
-          SESSION_ID,
-          "system_msg",
-          "SYS_MSG_0120"
-        ); //Create Mode Denied
+        _this.func.utils.alerts.invoke(SESSION_ID, 'system_msg', 'SYS_MSG_0120'); //Create Mode Denied
       }
 
       _.forEach(_ds.data_feed.rows_added, function (val, key) {
         data[key] = val;
       });
 
-      delete _ds.data_feed.rows_added["newRecord"];
-      save_ret = await _this.func.common.db(
-        SESSION_ID,
-        "dbs_create",
-        data,
-        {},
-        dsSessionP
-      );
+      delete _ds.data_feed.rows_added['newRecord'];
+      save_ret = await _this.func.common.db(SESSION_ID, 'dbs_create', data, {}, dsSessionP);
       refresh_document_changes_for_realtime_update(SESSION_ID, {
         row_id: save_ret.data.id,
         table_id: dataSourceTableId,
@@ -143,26 +106,18 @@ _db.save_data = async function (SESSION_ID, dsSessionP, keyP) {
     // delete
     //===============
     if (_ds.data_feed.rows_deleted?.length) {
-      let ids = [];
-      for await (const [key, val] of Object.entries(
-        _ds.data_feed.rows_deleted
-      )) {
-        ids.push(val);
+      data.ids = [];
+      for await (const [key, val] of Object.entries(_ds.data_feed.rows_deleted)) {
+        data.ids.push(val);
 
         try {
           const row_idx = func.common.find_ROWID_idx(_ds, val);
 
           delete _ds.data_feed.rows[row_idx];
-        } catch (error) { }
+        } catch (error) {}
       }
       _ds.data_feed.rows_deleted = [];
-      save_ret = await _this.func.common.db(
-        SESSION_ID,
-        "dbs_delete",
-        data,
-        {},
-        dsSessionP
-      );
+      save_ret = await _this.func.common.db(SESSION_ID, 'dbs_delete', data, {}, dsSessionP);
       refresh_document_changes_for_realtime_update(SESSION_ID, {
         row_id: save_ret.data?.id?.[0],
         table_id: dataSourceTableId,
@@ -173,56 +128,40 @@ _db.save_data = async function (SESSION_ID, dsSessionP, keyP) {
     // update
     //===============
     if (_ds.data_feed.rows_changed?.length) {
-      for await (const [key, row_id] of Object.entries(
-        _ds.data_feed.rows_changed
-      )) {
-        if (row_id === "datasource_main") continue;
+      for await (const [key, row_id] of Object.entries(_ds.data_feed.rows_changed)) {
+        if (row_id === 'datasource_main') continue;
 
         let data = { prog_id: _ds.prog_id };
 
         try {
           const row_idx = func.common.find_ROWID_idx(_ds, row_id);
 
-          data.table_data = await clean_virtual_fields(
-            _ds._dataSourceTableId,
-            _ds.data_feed.rows[row_idx]
-          );
+          data.table_data = await clean_virtual_fields(_ds._dataSourceTableId, _ds.data_feed.rows[row_idx]);
         } catch (err) {
           console.error(err);
         }
 
         data.table_id = _ds._dataSourceTableId;
         data.row_id = row_id;
-        save_ret = await _this.func.common.db(
-          SESSION_ID,
-          "dbs_update",
-          data,
-          {},
-          dsSessionP
-        );
+        save_ret = await _this.func.common.db(SESSION_ID, 'dbs_update', data, {}, dsSessionP);
         refresh_document_changes_for_realtime_update(SESSION_ID, {
           row_id: save_ret.data?.id?.[0],
           table_id: dataSourceTableId,
         });
-
       }
       return save_ret;
     }
     return;
   }
   // alert Program Read Only
-  if (_view_obj.properties.menuType !== "set_data") {
-    return _this.func.utils.alerts.invoke(
-      SESSION_ID,
-      "system_msg",
-      "SYS_MSG_0126"
-    ); //Program Read Only
+  if (_view_obj.properties.menuType !== 'set_data') {
+    return _this.func.utils.alerts.invoke(SESSION_ID, 'system_msg', 'SYS_MSG_0126'); //Program Read Only
   }
 
   // set_data
   var mode = _ds.set_mode; //screenInfo.crudMode;
 
-  if (!mode || mode === "U") {
+  if (!mode || mode === 'U') {
     let data = { prog_id: _ds.prog_id };
     data.table_id = _ds._dataSourceTableId;
     data.row_id = _ds.currentRecordId;
@@ -231,55 +170,32 @@ _db.save_data = async function (SESSION_ID, dsSessionP, keyP) {
     try {
       const row_idx = func.common.find_ROWID_idx(_ds, _ds.currentRecordId);
 
-      data.table_data = await clean_virtual_fields(
-        _ds._dataSourceTableId,
-        _ds.data_feed.rows[row_idx]
-      );
+      data.table_data = await clean_virtual_fields(_ds._dataSourceTableId, _ds.data_feed.rows[row_idx]);
     } catch (err) {
       console.error(err);
     }
 
-    save_ret = await _this.func.common.db(
-      SESSION_ID,
-      "dbs_update",
-      data,
-      {},
-      dsSessionP
-    );
+    save_ret = await _this.func.common.db(SESSION_ID, 'dbs_update', data, {}, dsSessionP);
     refresh_document_changes_for_realtime_update(SESSION_ID, {
       row_id: save_ret.data?.id?.[0],
       table_id: dataSourceTableId,
     });
   }
-  if (mode === "D") {
+  if (mode === 'D') {
     // _id = _ds.key._id;
     let data = { prog_id: _ds.prog_id };
     data.table_id = _ds._dataSourceTableId;
     data.ids = [_ds.currentRecordId];
-    save_ret = await _this.func.common.db(
-      SESSION_ID,
-      "dbs_delete",
-      data,
-      {},
-      dsSessionP
-    );
+    save_ret = await _this.func.common.db(SESSION_ID, 'dbs_delete', data, {}, dsSessionP);
     refresh_document_changes_for_realtime_update(SESSION_ID, {
       row_id: save_ret.data?.id?.[0],
       table_id: dataSourceTableId,
     });
     return save_ret;
   }
-  if (mode === "C") {
-    if (
-      _view_obj.properties.crudMode !== "C" &&
-      _view_obj.properties.crudMode === "U" &&
-      !_view_obj.properties.allowCreate
-    ) {
-      return _this.func.utils.alerts.invoke(
-        SESSION_ID,
-        "system_msg",
-        "SYS_MSG_0120"
-      ); //Create Mode Denied
+  if (mode === 'C') {
+    if (_view_obj.properties.crudMode !== 'C' && _view_obj.properties.crudMode === 'U' && !_view_obj.properties.allowCreate) {
+      return _this.func.utils.alerts.invoke(SESSION_ID, 'system_msg', 'SYS_MSG_0120'); //Create Mode Denied
     }
 
     let data = { prog_id: _ds.prog_id };
@@ -289,13 +205,7 @@ _db.save_data = async function (SESSION_ID, dsSessionP, keyP) {
       const row_idx = func.common.find_ROWID_idx(_ds, _ds.currentRecordId);
 
       data.table_data = _ds.data_feed.rows[row_idx];
-      save_ret = await _this.func.common.db(
-        SESSION_ID,
-        "dbs_create",
-        data,
-        {},
-        dsSessionP
-      );
+      save_ret = await _this.func.common.db(SESSION_ID, 'dbs_create', data, {}, dsSessionP);
       refresh_document_changes_for_realtime_update(SESSION_ID, {
         row_id: save_ret.data.id,
         table_id: dataSourceTableId,
@@ -312,29 +222,19 @@ _db.get_db_driver = async function (SESSION_ID, dsSessionP) {
 
   if (dsSessionP) {
     var _ds = _this.SESSION_OBJ[SESSION_ID].DS_GLB[dsSessionP];
-    let _view_obj = await _this.func.utils.VIEWS_OBJ.get(
-      SESSION_ID,
-      _ds.prog_id
-    );
+    let _view_obj = await _this.func.utils.VIEWS_OBJ.get(SESSION_ID, _ds.prog_id);
     var dataSourceTableId = _view_obj?.progDataSource?.dataSourceTableId;
 
     if (!dataSourceTableId) {
-      _this.func.utils.alerts.invoke(SESSION_ID, "system_msg", "SYS_MSG_0105"); //Table repository missing
+      _this.func.utils.alerts.invoke(SESSION_ID, 'system_msg', 'SYS_MSG_0105'); //Table repository missing
       return;
     }
-    let file_ret = await _this.func.utils.FILES_OBJ.get(
-      SESSION_ID,
-      dataSourceTableId
-    );
-    db_driver = file_ret.properties.db_driver || "xuda";
+    let file_ret = await _this.func.utils.FILES_OBJ.get(SESSION_ID, dataSourceTableId);
+    db_driver = file_ret.properties.db_driver || 'xuda';
   }
 
-  if (
-    _this.SESSION_OBJ[SESSION_ID].engine_mode === "live_preview" &&
-    !db_driver &&
-    _this.SESSION_OBJ[SESSION_ID].app_id === "temp"
-  ) {
-    db_driver = "pouchdb";
+  if (_this.SESSION_OBJ[SESSION_ID].engine_mode === 'live_preview' && !db_driver && _this.SESSION_OBJ[SESSION_ID].app_id === 'temp') {
+    db_driver = 'pouchdb';
   }
 
   return db_driver;
@@ -360,18 +260,15 @@ _db.get_query = async function (
     filterModelUserMongo,
     filterModelUserSql,
   },
-  dataSourceFilterModelType = "index",
-  total_fields_info
+  dataSourceFilterModelType = 'index',
+  total_fields_info,
 ) {
   const get_fields = async function (_ds) {
     var fields = [];
-    const _view_obj = await _this.func.utils.VIEWS_OBJ.get(
-      SESSION_ID,
-      _ds.prog_id
-    );
+    const _view_obj = await _this.func.utils.VIEWS_OBJ.get(SESSION_ID, _ds.prog_id);
     if (_view_obj.progFields) {
       for (let val of _view_obj.progFields) {
-        if (val.data.type === "table") {
+        if (val.data.type === 'table') {
           fields.push(val.data.field_id);
         }
       }
@@ -388,26 +285,19 @@ _db.get_query = async function (
     var query_string;
     if (queryP.indexId) {
       if (countP && queryP.desc) {
-        query_string = `startkey=${JSON.stringify(
-          queryP.endkey
-        )}&endkey=${JSON.stringify(queryP.startkey)}`;
+        query_string = `startkey=${JSON.stringify(queryP.endkey)}&endkey=${JSON.stringify(queryP.startkey)}`;
       } else {
-        query_string = `startkey=${JSON.stringify(
-          queryP.startkey
-        )}&endkey=${JSON.stringify(queryP.endkey)}&desc=${queryP.desc}`;
+        query_string = `startkey=${JSON.stringify(queryP.startkey)}&endkey=${JSON.stringify(queryP.endkey)}&desc=${queryP.desc}`;
       }
     } else {
-      query_string = "key=" + queryP.table_id;
+      query_string = 'key=' + queryP.table_id;
     }
     var db_driver = await _db.get_db_driver(SESSION_ID, dsSessionP);
     var fields_arr = await get_fields(ds);
 
     const response = {
       success: async function (json) {
-        if (
-          dsSessionP &&
-          !_this.SESSION_OBJ[SESSION_ID]?.DS_GLB?.[dsSessionP]
-        ) {
+        if (dsSessionP && !_this.SESSION_OBJ[SESSION_ID]?.DS_GLB?.[dsSessionP]) {
           return;
         }
 
@@ -444,7 +334,7 @@ _db.get_query = async function (
         if (dsSessionP)
           _this.func.utils.debug.log(SESSION_ID, ds._dataSourceTableId, {
             module: ds.viewModule,
-            action: "read",
+            action: 'read',
             prop: sourceP,
             details: query_string,
             result: data.rows ? data.rows.length : 0,
@@ -452,7 +342,7 @@ _db.get_query = async function (
             source: viewSourceDescP,
             json: data,
             fields: _.assignIn(ds.locate_from, ds.locate_to),
-            type: "file",
+            type: 'file',
             dsSession: dsSessionP,
           });
 
@@ -462,30 +352,21 @@ _db.get_query = async function (
         if (dsSessionP && !ds) return;
         if (dsSessionP) {
           var err_msg = err && err.data ? err.data : err;
-          _this.func.utils.debug.log(
-            SESSION_ID,
-            _this.SESSION_OBJ[SESSION_ID].DS_GLB[dsSessionP]._dataSourceTableId,
-            {
-              module: ds.viewModule,
-              action: "read",
-              prop: sourceP,
-              details: query_string,
-              result: null,
-              error: err_msg,
-              source: viewSourceDescP,
-              json: null,
-              fields: _.assignIn(ds.locate_from, ds.locate_to),
-              type: "file",
-              dsSession: dsSessionP,
-            }
-          );
+          _this.func.utils.debug.log(SESSION_ID, _this.SESSION_OBJ[SESSION_ID].DS_GLB[dsSessionP]._dataSourceTableId, {
+            module: ds.viewModule,
+            action: 'read',
+            prop: sourceP,
+            details: query_string,
+            result: null,
+            error: err_msg,
+            source: viewSourceDescP,
+            json: null,
+            fields: _.assignIn(ds.locate_from, ds.locate_to),
+            type: 'file',
+            dsSession: dsSessionP,
+          });
         }
-        _this.func.utils.debug_report(
-          SESSION_ID,
-          "datasource couchDB query " + sourceP,
-          err_msg,
-          "E"
-        );
+        _this.func.utils.debug_report(SESSION_ID, 'datasource couchDB query ' + sourceP, err_msg, 'E');
 
         return {
           rows: [],
@@ -517,7 +398,7 @@ _db.get_query = async function (
     data.endkey = JSON.stringify(queryP.endkey);
 
     if (countP && queryP.desc) {
-      data.sortOrder = "asc";
+      data.sortOrder = 'asc';
       data.startkey = JSON.stringify(queryP.endkey);
       data.endkey = JSON.stringify(queryP.startkey);
     }
@@ -540,9 +421,7 @@ _db.get_query = async function (
       data.filterModelSql = JSON.stringify(filterModel.filterModelSql);
     }
     if (!_.isEmpty(filterModel?.filterModelUserMongo)) {
-      data.filterModelUserMongo = JSON.stringify(
-        filterModel.filterModelUserMongo
-      );
+      data.filterModelUserMongo = JSON.stringify(filterModel.filterModelUserMongo);
     }
     if (filterModel?.filterModelUserSql) {
       data.filterModelUserSql = JSON.stringify(filterModel.filterModelUserSql);
@@ -558,13 +437,7 @@ _db.get_query = async function (
     }
 
     try {
-      const json = await _this.func.common.db(
-        SESSION_ID,
-        "dbs_read",
-        data,
-        { node: true },
-        dsSessionP
-      );
+      const json = await _this.func.common.db(SESSION_ID, 'dbs_read', data, { node: true }, dsSessionP);
       return await response.success(json);
     } catch (e) {
       return await response.error(e?.message || e?.data || e);
@@ -572,39 +445,24 @@ _db.get_query = async function (
   };
 
   var db_driver = await this.get_db_driver(SESSION_ID, dsSessionP);
-  if (
-    db_driver === "pouchdb" &&
-    _this.glb.IS_WORKER &&
-    !_this.SESSION_OBJ[SESSION_ID].engine_mode === "live_preview"
-  ) {
-    var callback_id = _this.func.utils.set_callback_queue(
-      SESSION_ID,
-      callbackP
-    );
-    var obj = _this.func.utils.clean_returned_datasource(
-      SESSION_ID,
-      dsSessionP
-    );
-    return _this.func.utils.post_back_to_client(
-      SESSION_ID,
-      "execute_local_db_query",
-      _this.SESSION_OBJ[SESSION_ID].worker_id,
-      {
-        ds_obj: obj,
-        dsSessionP,
-        table_id,
-        queryP,
-        dsSessionP,
-        viewSourceDescP,
-        sourceP,
-        reduceP,
-        skipP,
-        limitP,
-        countP,
-        idsP,
-        callback_id,
-      }
-    );
+  if (db_driver === 'pouchdb' && _this.glb.IS_WORKER && !_this.SESSION_OBJ[SESSION_ID].engine_mode === 'live_preview') {
+    var callback_id = _this.func.utils.set_callback_queue(SESSION_ID, callbackP);
+    var obj = _this.func.utils.clean_returned_datasource(SESSION_ID, dsSessionP);
+    return _this.func.utils.post_back_to_client(SESSION_ID, 'execute_local_db_query', _this.SESSION_OBJ[SESSION_ID].worker_id, {
+      ds_obj: obj,
+      dsSessionP,
+      table_id,
+      queryP,
+      dsSessionP,
+      viewSourceDescP,
+      sourceP,
+      reduceP,
+      skipP,
+      limitP,
+      countP,
+      idsP,
+      callback_id,
+    });
   }
   return await run_local();
 };
@@ -667,20 +525,19 @@ _db.save_indicator = function (SESSION_ID, stateP) {
 const init_xuda_dbs_plugin = async function (SESSION_ID) {
   var _session = _this.SESSION_OBJ[SESSION_ID];
 
-  const plugin_name = "@xuda.io/xuda-dbs-plugin-xuda";
+  const plugin_name = '@xuda.io/xuda-dbs-plugin-xuda';
 
   const get_path = function (plugin_name, resource) {
-    var path = `https://${_session.domain}/plugins/${plugin_name}${resource ? "/" + resource : ""
-      }?app_id=${_session.app_id}`;
+    var path = `https://${_session.domain}/plugins/${plugin_name}${resource ? '/' + resource : ''}?app_id=${_session.app_id}`;
 
     return path;
   };
 
   try {
-    _this.xuda_dbs_plugin = await import(get_path(plugin_name, "studio.mjs"));
+    _this.xuda_dbs_plugin = await import(get_path(plugin_name, 'studio.mjs'));
 
     const db = await func.utils.connect_pouchdb(SESSION_ID);
-    await _db.call_pouch_xuda_dbs_plugin(SESSION_ID, "create_design", { db });
+    await _db.call_pouch_xuda_dbs_plugin(SESSION_ID, 'create_design', { db });
   } catch (err) {
     return console.error(err.message);
   }
@@ -691,10 +548,7 @@ _db.call_pouch_xuda_dbs_plugin = async function (SESSION_ID, method, params) {
     try {
       // var table_obj = {};
       if (params.e) {
-        params.table_obj = await func.utils.DOCS_OBJ.get(
-          SESSION_ID,
-          params.e.table_id
-        );
+        params.table_obj = await func.utils.DOCS_OBJ.get(SESSION_ID, params.e.table_id);
       }
 
       await _this.xuda_dbs_plugin[method](params, resolve, reject);
@@ -706,29 +560,26 @@ _db.call_pouch_xuda_dbs_plugin = async function (SESSION_ID, method, params) {
 _db.pouch = {};
 _db.pouch.dbs_read = async function (SESSION_ID, e) {
   const db = await func.utils.connect_pouchdb(SESSION_ID);
-  return await _db.call_pouch_xuda_dbs_plugin(SESSION_ID, "read", { db, e });
+  return await _db.call_pouch_xuda_dbs_plugin(SESSION_ID, 'read', { db, e });
 };
 _db.pouch.dbs_create = async function (SESSION_ID, e) {
   const db = await func.utils.connect_pouchdb(SESSION_ID);
-  return await _db.call_pouch_xuda_dbs_plugin(SESSION_ID, "create", { db, e });
+  return await _db.call_pouch_xuda_dbs_plugin(SESSION_ID, 'create', { db, e });
 };
 _db.pouch.dbs_delete = async function (SESSION_ID, e) {
   const db = await func.utils.connect_pouchdb(SESSION_ID);
-  return await _db.call_pouch_xuda_dbs_plugin(SESSION_ID, "del", { db, e });
+  return await _db.call_pouch_xuda_dbs_plugin(SESSION_ID, 'del', { db, e });
 };
 _db.pouch.dbs_update = async function (SESSION_ID, e) {
   const db = await func.utils.connect_pouchdb(SESSION_ID);
-  return await _db.call_pouch_xuda_dbs_plugin(SESSION_ID, "update", { db, e });
+  return await _db.call_pouch_xuda_dbs_plugin(SESSION_ID, 'update', { db, e });
 };
 
 _db.pouch.init_db_replication = async function (SESSION_ID) {
   const db = await func.utils.connect_pouchdb(SESSION_ID);
   var _session = _this.SESSION_OBJ[SESSION_ID];
 
-  if (
-    _session.url_params.avoid_local ||
-    (_session.engine_mode !== "live_preview" && !_session.opt.enable_offline)
-  ) {
+  if (_session.url_params.avoid_local || (_session.engine_mode !== 'live_preview' && !_session.opt.enable_offline)) {
     return;
   }
 
@@ -739,7 +590,7 @@ _db.pouch.init_db_replication = async function (SESSION_ID) {
       live: true,
       include_docs: true,
     })
-    .on("change", function (change) {
+    .on('change', function (change) {
       // handle change
 
       if (!change.doc.udfData) return;
@@ -749,11 +600,11 @@ _db.pouch.init_db_replication = async function (SESSION_ID) {
         table_id: change.doc.udfData.udffileid,
       });
     })
-    .on("complete", function (info) {
+    .on('complete', function (info) {
       // changes() was canceled
-      console.log("complete", info);
+      console.log('complete', info);
     })
-    .on("error", function (err) {
+    .on('error', function (err) {
       console.error(err);
     });
 
@@ -763,42 +614,41 @@ _db.pouch.init_db_replication = async function (SESSION_ID) {
   const db_name = APP_OBJ[_session.app_id].app_db_name;
   const rep = db.replicate
     .to(`https://${_session.domain}/db/${db_name}`, {
-      selector: { docType: "database" },
+      selector: { docType: 'database' },
       live: true,
       retry: true,
       fetch: function (url, opts) {
         if (_session.gtp_token) {
-          opts.headers.set("xu-gtp-token", _session.gtp_token);
+          opts.headers.set('xu-gtp-token', _session.gtp_token);
         }
-        if (_session.app_token)
-          opts.headers.set("xu-app-token", _session.app_token);
+        if (_session.app_token) opts.headers.set('xu-app-token', _session.app_token);
         {
-          opts.headers.set("xu-db", db_name);
+          opts.headers.set('xu-db', db_name);
         }
         return PouchDB.fetch(url, opts);
       },
     })
-    .on("change", function (info) {
+    .on('change', function (info) {
       // handle change
     })
-    .on("paused", function (err) {
+    .on('paused', function (err) {
       if (err) {
         return set_replication_stat(SESSION_ID, null, 2);
       }
       set_replication_stat(SESSION_ID, null, 3);
       // replication paused (e.g. replication up to date, user went offline)
     })
-    .on("active", function () {
+    .on('active', function () {
       // replicate resumed (e.g. new changes replicating, user went back online)
     })
-    .on("denied", function (err) {
+    .on('denied', function (err) {
       set_replication_stat(SESSION_ID, null, 2);
       // a document failed to replicate (e.g. due to permissions)
     })
-    .on("complete", function (info) {
+    .on('complete', function (info) {
       // handle complete
     })
-    .on("error", function (err) {
+    .on('error', function (err) {
       set_replication_stat(SESSION_ID, null, 2);
       // handle error
     });
@@ -814,12 +664,11 @@ _db.pouch.set_db_replication_from_server = async function (SESSION_ID) {
   const remote_db = new PouchDB(remote_db_url, {
     fetch: function (url, opts) {
       if (_session.gtp_token) {
-        opts.headers.set("xu-gtp-token", _session.gtp_token);
+        opts.headers.set('xu-gtp-token', _session.gtp_token);
       }
-      if (_session.app_token)
-        opts.headers.set("xu-app-token", _session.app_token);
+      if (_session.app_token) opts.headers.set('xu-app-token', _session.app_token);
       {
-        opts.headers.set("xu-db", db_name);
+        opts.headers.set('xu-db', db_name);
       }
       return PouchDB.fetch(url, opts);
     },
@@ -837,23 +686,22 @@ _db.pouch.set_db_replication_from_server = async function (SESSION_ID) {
       doc.stat_reason = reason;
       try {
         db.put(doc);
-      } catch (err) { }
-    } catch (err) { }
+      } catch (err) {}
+    } catch (err) {}
   };
   const download_documents = async function (rep_doc) {
     await write_stat(rep_doc._id, 2);
 
     const remote_db = new PouchDB(remote_db_url, {
       fetch: function (url, opts) {
-        opts.headers.set("xu-prog_id", rep_doc.prog_id);
+        opts.headers.set('xu-prog_id', rep_doc.prog_id);
 
         if (_session.gtp_token) {
-          opts.headers.set("xu-gtp-token", _session.gtp_token);
+          opts.headers.set('xu-gtp-token', _session.gtp_token);
         }
-        if (_session.app_token)
-          opts.headers.set("xu-app-token", _session.app_token);
+        if (_session.app_token) opts.headers.set('xu-app-token', _session.app_token);
         {
-          opts.headers.set("xu-db", db_name);
+          opts.headers.set('xu-db', db_name);
         }
         return PouchDB.fetch(url, opts);
       },
@@ -861,18 +709,13 @@ _db.pouch.set_db_replication_from_server = async function (SESSION_ID) {
 
     const ret = await remote_db.find({
       selector: rep_doc.selector,
-      fields: ["_id"],
+      fields: ['_id'],
       limit: 9999999999,
       // prog_id: rep_doc.prog_id,
     });
 
     if (ret?.code < 0) {
-      return func.utils.debug_report(
-        SESSION_ID,
-        "download_documents",
-        ret.data,
-        "E"
-      );
+      return func.utils.debug_report(SESSION_ID, 'download_documents', ret.data, 'E');
     }
 
     try {
@@ -884,20 +727,19 @@ _db.pouch.set_db_replication_from_server = async function (SESSION_ID) {
         .from(remote_db_url, {
           doc_ids,
           retry: true,
-          style: "main_only",
+          style: 'main_only',
           fetch: function (url, opts) {
             if (_session.gtp_token) {
-              opts.headers.set("xu-gtp-token", _session.gtp_token);
+              opts.headers.set('xu-gtp-token', _session.gtp_token);
             }
-            if (_session.app_token)
-              opts.headers.set("xu-app-token", _session.app_token);
+            if (_session.app_token) opts.headers.set('xu-app-token', _session.app_token);
             {
-              opts.headers.set("xu-db", db_name);
+              opts.headers.set('xu-db', db_name);
             }
             return PouchDB.fetch(url, opts);
           },
         })
-        .on("paused", async function (err) {
+        .on('paused', async function (err) {
           // replication paused (e.g. replication up to date, user went offline)
 
           if (err) {
@@ -909,7 +751,7 @@ _db.pouch.set_db_replication_from_server = async function (SESSION_ID) {
         });
     } catch (err) {
       await write_stat(rep_doc._id, 2, err.message);
-      console.error("replication from error", err);
+      console.error('replication from error', err);
     }
     // console.log(ret);
   };
@@ -923,15 +765,15 @@ _db.pouch.set_db_replication_from_server = async function (SESSION_ID) {
   try {
     _this.db_changes_store = remote_db
       .changes({
-        since: "now",
+        since: 'now',
         live: true,
         timeout: 300000, // 5 min
-        style: "main_only",
+        style: 'main_only',
         include_docs: false,
         // heartbeat: 10000
       })
-      .on("change", async function (change) {
-        if (change.id.substr(0, 4) !== "dbs-") return;
+      .on('change', async function (change) {
+        if (change.id.substr(0, 4) !== 'dbs-') return;
 
         if (_this.db_replication_from_stat !== 3) {
           set_replication_stat(SESSION_ID, 3);
@@ -943,15 +785,14 @@ _db.pouch.set_db_replication_from_server = async function (SESSION_ID) {
           db.replicate.from(remote_db_url, {
             doc_ids: [change.id],
             retry: true,
-            style: "main_only",
+            style: 'main_only',
             fetch: function (url, opts) {
               if (_session.gtp_token) {
-                opts.headers.set("xu-gtp-token", _session.gtp_token);
+                opts.headers.set('xu-gtp-token', _session.gtp_token);
               }
-              if (_session.app_token)
-                opts.headers.set("xu-app-token", _session.app_token);
+              if (_session.app_token) opts.headers.set('xu-app-token', _session.app_token);
               {
-                opts.headers.set("xu-db", db_name);
+                opts.headers.set('xu-db', db_name);
               }
               return PouchDB.fetch(url, opts);
             },
@@ -959,7 +800,7 @@ _db.pouch.set_db_replication_from_server = async function (SESSION_ID) {
         } catch (err) {
           // new doc change
           try {
-            const table_id = change.id.split("_")[0].substr(4);
+            const table_id = change.id.split('_')[0].substr(4);
 
             for (let doc of rep_docs) {
               if (doc.table_id === table_id) {
@@ -971,10 +812,10 @@ _db.pouch.set_db_replication_from_server = async function (SESSION_ID) {
           }
         }
       })
-      .on("complete", function (info) {
+      .on('complete', function (info) {
         // changes() was canceled
       })
-      .on("error", function (err) {
+      .on('error', function (err) {
         console.error(err);
         set_replication_stat(SESSION_ID, 2);
         _this.db_changes_store.cancel();
@@ -985,10 +826,7 @@ _db.pouch.set_db_replication_from_server = async function (SESSION_ID) {
 
   return;
 };
-_db.pouch.remove_db_replication_from_server = async function (
-  SESSION_ID,
-  rep_id
-) {
+_db.pouch.remove_db_replication_from_server = async function (SESSION_ID, rep_id) {
   const db = await func.utils.connect_pouchdb(SESSION_ID);
 
   try {
@@ -997,16 +835,14 @@ _db.pouch.remove_db_replication_from_server = async function (
     // _this.db_replication_store[rep_id].cancel();
     db.remove(doc);
     // delete _this.db_replication_store[rep_id];
-  } catch (error) { }
+  } catch (error) {}
 };
 
-_db.pouch.get_replications = async function (
-  SESSION_ID = Object.keys(SESSION_OBJ)[0]
-) {
+_db.pouch.get_replications = async function (SESSION_ID = Object.keys(SESSION_OBJ)[0]) {
   const db = await func.utils.connect_pouchdb(SESSION_ID);
   // source: "runtime"
   let ret = await db.find({
-    selector: { docType: "rep_request" },
+    selector: { docType: 'rep_request' },
   });
 
   return ret.docs;
@@ -1029,42 +865,28 @@ const set_replication_stat = async function (SESSION_ID, from_stat, to_stat) {
   if (to_stat) _this.db_replication_to_stat = to_stat;
 
   var data = {};
-  if (
-    _this.db_replication_from_stat === 3 &&
-    _this.db_replication_to_stat === 3
-  ) {
+  if (_this.db_replication_from_stat === 3 && _this.db_replication_to_stat === 3) {
     data.SYS_GLOBAL_BOL_REPLICATION_STAT = 1;
-    console.info("Replication On");
+    console.info('Replication On');
   } else {
     data.SYS_GLOBAL_BOL_REPLICATION_STAT = 0;
-    console.info("Replication Off");
+    console.info('Replication Off');
   }
 
   var datasource_changes = {
     [0]: {
-      ["data_system"]: data,
+      ['data_system']: data,
     },
   };
   await func.datasource.update(SESSION_ID, datasource_changes);
 };
 
-const refresh_document_changes_for_realtime_update = function (
-  SESSION_ID,
-  doc_change
-) {
+const refresh_document_changes_for_realtime_update = function (SESSION_ID, doc_change) {
   var _session = _this.SESSION_OBJ[SESSION_ID];
 
   if (glb.IS_WORKER) {
-    return func.utils.post_back_to_client(
-      SESSION_ID,
-      "refresh_document_changes_for_realtime_update",
-      _session.worker_id,
-      { doc_change }
-    );
+    return func.utils.post_back_to_client(SESSION_ID, 'refresh_document_changes_for_realtime_update', _session.worker_id, { doc_change });
   }
 
-  func.UI.screen.refresh_document_changes_for_realtime_update(
-    SESSION_ID,
-    doc_change
-  );
+  func.UI.screen.refresh_document_changes_for_realtime_update(SESSION_ID, doc_change);
 };