@xuda.io/runtime-bundle 1.0.505 → 1.0.507

package/js/xuda-runtime-bundle.js

@@ -28260,6 +28260,22 @@ func.UI.update_xu_ref = function (SESSION_ID, dsSessionP, ref_field_id, $elm) {
     SYS_GLOBAL_OBJ_REFS[ref_field_id].attributes = attributes;
     SYS_GLOBAL_OBJ_REFS[ref_field_id].xu_ui_id = $elm.attr('xu-ui-id');
   }
+
+  // let obj = { ds: _ds, data: _ds?.data_feed?.rows?.[row_idx] || {}, props: _ds.in_parameters || {} };
+
+  // if ($elm) {
+  //   const attributes = $elm?.data()?.xuData?.xuPanelProps || $elm?.data()?.xuData?.debug_info?.attribute_stat || {};
+  //   obj.attributes = attributes;
+  //   obj.xu_ui_id = $elm.attr('xu-ui-id');
+  // }
+
+  // func.datasource.update(SESSION_ID, {
+  //   [0]: {
+  //     ['datasource_main']: {
+  //       'data_system.SYS_GLOBAL_OBJ_REFS': { [`${ref_field_id}`]: obj },
+  //     },
+  //   },
+  // });
 };
 
 func.UI.find_field_in_progUi_attributes = function (progUi, field_id, prop, tag_name) {
@@ -28370,12 +28386,15 @@ func.datasource.create = async function (
     };
 
     var run_at = _prog_obj?.properties?.runAt;
-    if (_session.opt.app_computing_mode === 'main') {
-      run_at = 'client';
-    }
 
-    if (_prog_obj?.properties.menuType === 'globals') {
-      run_at = 'client';
+    if (_session.engine_mode !== 'live_preview') {
+      if (_session.opt.app_computing_mode === 'main') {
+        run_at = 'client';
+      }
+
+      if (_prog_obj?.properties.menuType === 'globals') {
+        run_at = 'client';
+      }
     }
 
     if (!run_at && parentDataSourceNoP && _session.DS_GLB[parentDataSourceNoP]) {
@@ -28686,6 +28705,19 @@ func.datasource.prepare = async function (SESSION_ID, prog_id, dataSourceNoP, pa
 
   _ds.stat = 'busy';
   _ds._run_at = run_atP;
+
+  if (_ds.refreshed) {
+    await func.datasource.update(SESSION_ID, {
+      [_ds.dsSession]: {
+        ['datasource_main']: {
+          stat: 'busy',
+          stat_ts: Date.now(),
+          is_worker: glb.IS_WORKER,
+        },
+      },
+    });
+  }
+
   // init_v();
 
   if (IS_DATASOURCE_REFRESH) {
@@ -30114,7 +30146,7 @@ func.datasource.del = function (SESSION_ID, dsP) {
   }
   perform_delete();
 };
-func.datasource.update = async function (SESSION_ID, datasource_changes, update_local_scope_only, avoid_refresh) {
+func.datasource.update_old = async function (SESSION_ID, datasource_changes, update_local_scope_only, avoid_refresh) {
   return new Promise(async (resolve, reject) => {
     var _session = SESSION_OBJ[SESSION_ID];
 
@@ -30217,7 +30249,202 @@ func.datasource.update = async function (SESSION_ID, datasource_changes, update_
           if (typeof fields_data === 'object') {
             if (glb.GLOBAL_VARS[field_id]) {
               _ds.data_system[field_id] = value;
+              continue;
+            }
+
+            // try {
+            const row_idx = func.common.find_ROWID_idx(_ds, record_id);
+            if (_ds.data_feed.rows[row_idx][field_id] !== value) {
+              _ds.data_feed.rows[row_idx][field_id] = value;
+              await set_fieldComputed_dependencies(dataSource, field_id, null);
+
+              // search the field in refs
+              update_xu_ref();
+
+              if (!update_local_scope_only) {
+                let tree_ret = await func.utils.TREE_OBJ.get(SESSION_ID, _ds.prog_id);
+                if (glb.IS_WORKER) {
+                  // RUN AT SERVER
+                  if (tree_ret.menuType === 'globals' || tree_ret.menuType === 'component') {
+                    const _progFields = await func.datasource.get_progFields(SESSION_ID, dataSource);
+                    let view_field_obj = func.common.find_item_by_key(_progFields, 'field_id', field_id);
+                    if (!view_field_obj?.data?.serverField && record_id !== 'data_system') {
+                      if (!client_datasource_changes[dataSource]) {
+                        client_datasource_changes[dataSource] = {};
+                      }
+                      if (!client_datasource_changes[dataSource][record_id]) {
+                        client_datasource_changes[dataSource][record_id] = {};
+                      }
+                      client_datasource_changes[dataSource][record_id][field_id] = value;
+                    }
+                  }
+                } else {
+                  // RUN AT CLIENT
+                  if ((tree_ret.menuType === 'component' && _ds._run_at !== 'client') || tree_ret.menuType === 'globals') {
+                    if (!server_datasource_changes[dataSource]) {
+                      server_datasource_changes[dataSource] = {};
+                    }
+                    if (!server_datasource_changes[dataSource][record_id]) {
+                      server_datasource_changes[dataSource][record_id] = {};
+                    }
+                    server_datasource_changes[dataSource][record_id][field_id] = value;
+                  }
+                }
+              }
+
+              if (!fields_changed.includes(field_id)) {
+                fields_changed.push(field_id);
+              }
+              if (!datasource_changed.includes(dataSource)) {
+                datasource_changed.push(dataSource);
+              }
+
+              if (!_ds.data_feed.rows_changed) {
+                _ds.data_feed.rows_changed = [];
+              }
+              if (!_ds.data_feed.rows_changed.includes(record_id)) _ds.data_feed.rows_changed.push(record_id);
+            }
+          } else if (fields_data === 'set') {
+            _ds.currentRecordId = record_id;
+          }
+        }
+      }
+    }
+
+    if (glb.IS_WORKER) {
+      if (!update_local_scope_only && !_.isEmpty(client_datasource_changes)) {
+        func.utils.post_back_to_client(SESSION_ID, 'update_client_eventChangesResults_from_worker', _session.worker_id, client_datasource_changes);
+      }
+    } else {
+      if (!update_local_scope_only && !_.isEmpty(server_datasource_changes)) {
+        const ret = await func.index.call_worker(SESSION_ID, {
+          service: 'update_datasource_changes_from_client',
+          data: {
+            session_id: SESSION_ID,
+            datasource_changes: server_datasource_changes,
+          },
+          id: _ds.worker_id,
+        });
+      }
+      ///// REFRESH SCREEN
+      if (!avoid_refresh && fields_changed.length) {
+        await func.UI.screen.refresh_xu_attributes(SESSION_ID, fields_changed);
+        // await removed from the below function cause to dead lock Mar 3 25
+        func.UI.screen.refresh_screen(
+          SESSION_ID,
+          fields_changed,
+          null,
+          datasource_changed[0], // refresh the current datasource only
+        );
+      }
+    }
+    resolve();
+  });
+};
+
+func.datasource.update = async function (SESSION_ID, datasource_changes, update_local_scope_only, avoid_refresh) {
+  return new Promise(async (resolve, reject) => {
+    var _session = SESSION_OBJ[SESSION_ID];
+
+    if (_session.IS_API || typeof IS_MASTER_WEBSOCKET !== 'undefined' || typeof IS_PROCESS_SERVER !== 'undefined') {
+      update_local_scope_only = true;
+    }
+
+    if (typeof glb.GLOBAL_VARS === 'undefined') {
+      glb.GLOBAL_VARS = (await func.common.get_module(SESSION_ID, 'xuda-system-globals-module.mjs')).system_globals;
+    }
+
+    const set_fieldComputed_dependencies = async function (dsNo, field_id, parent_ds) {
+      // iterate child ds
+      for (const [dsSession, _ds] of Object.entries(_session.DS_GLB)) {
+        if (parent_ds !== null) {
+          if (_ds.parentDataSourceNo != parent_ds) continue;
+        } else {
+          if (dsSession != dsNo) continue;
+        }
+        let tree_ret = await func.utils.TREE_OBJ.get(SESSION_ID, _ds.prog_id);
+        if (tree_ret.menuType === 'component' || tree_ret.menuType === 'globals') {
+          // check if field has fieldComputed property
+          const _progFields = await func.datasource.get_progFields(SESSION_ID, dsSession);
+          // find if field is computed
+          let fieldComputed_propExpressions, fieldComputed_id;
+          for await (const val of _progFields) {
+            const fieldId = val.data.field_id;
+
+            // if (fieldId !== field_id) continue
+            if (val.data.type !== 'virtual' || !val.props.fieldComputed) continue;
 
+            const _propExpressions = val.props?.propExpressions?.fieldValue;
+            if (_propExpressions && JSON.stringify(_propExpressions).includes(field_id)) {
+              fieldComputed_propExpressions = _propExpressions;
+              fieldComputed_id = fieldId;
+            }
+          }
+
+          if (!fieldComputed_id) return;
+
+          // iterate ds rows
+          for (const row of _ds.data_feed?.rows || []) {
+            // iterate row fields
+            for (const [key, val] of Object.entries(row)) {
+              if (key !== fieldComputed_id) continue;
+              try {
+                let ret = await func.expression.get(SESSION_ID, fieldComputed_propExpressions, dsNo, 'update', row._ROWID);
+
+                const row_idx = func.common.find_ROWID_idx(_ds, row._ROWID);
+                if (_ds.data_feed.rows[row_idx][fieldComputed_id] !== ret.result) {
+                  _ds.data_feed.rows[row_idx][fieldComputed_id] = ret.result;
+                  if (!fields_changed.includes(fieldComputed_id)) {
+                    fields_changed.push(fieldComputed_id);
+                  }
+                  if (!datasource_changed.includes(dsSession)) {
+                    datasource_changed.push(dsSession);
+                  }
+                }
+              } catch (err) {
+                console.error(err);
+              }
+            }
+          }
+        }
+        await set_fieldComputed_dependencies(dsNo, field_id, dsSession);
+      }
+    };
+
+    var fields_changed = [];
+    var datasource_changed = [];
+    let client_datasource_changes = {};
+    let server_datasource_changes = {};
+    // iterate changes datasource
+    for await (const [dataSource, row_data] of Object.entries(datasource_changes)) {
+      var _ds = _session.DS_GLB[dataSource];
+      if (!_ds) {
+        continue;
+      }
+
+      const update_xu_ref = async function () {
+        let _ds_0 = _session.DS_GLB[0];
+        for ([ref_name, val] of Object.entries(_ds_0.data_system['SYS_GLOBAL_OBJ_REFS'])) {
+          if (val.ds.dsSession == dataSource) {
+            func.UI.update_xu_ref(SESSION_ID, dataSource, ref_name);
+          }
+        }
+      };
+
+      // iterate changes records
+      for (const [record_id, fields_data] of Object.entries(row_data)) {
+        // iterate changes fields
+        for (const [field_id, value] of Object.entries(fields_data)) {
+          // mechanism to make update directly on the datasource object
+          if (record_id === 'datasource_main') {
+            _.set(_ds, field_id, value);
+            update_xu_ref();
+            continue;
+          }
+
+          if (typeof fields_data === 'object') {
+            if (glb.GLOBAL_VARS[field_id]) {
+              _ds.data_system[field_id] = value;
               continue;
             }
 
@@ -30229,15 +30456,6 @@ func.datasource.update = async function (SESSION_ID, datasource_changes, update_
 
               // search the field in refs
               update_xu_ref();
-              // let _ds_0 = _session.DS_GLB[0];
-              // for ([ref_name, val] of Object.entries(_ds_0.data_system['SYS_GLOBAL_OBJ_REFS'])) {
-              //   if (val.ds.dsSession == dataSource) {
-              //     func.UI.update_xu_ref(SESSION_ID, dataSource, ref_name);
-              //     // if (!fields_changed.includes(ref_name)) {
-              //     //   fields_changed.push(ref_name);
-              //     // }
-              //   }
-              // }
 
               if (!update_local_scope_only) {
                 let tree_ret = await func.utils.TREE_OBJ.get(SESSION_ID, _ds.prog_id);