@xuda.io/xuda-worker-bundle-min 1.3.1185 → 1.3.1187

package/index.js

@@ -3217,6 +3217,12 @@ func.datasource.run_events_functions = async function (
   calling_job,
   async_event
 ) {
+
+  if (typeof dataSourceSession === "undefined" || dataSourceSession === null) {
+    console.warn(`Event ${event_id} not exist or not found`)
+    return
+  }
+
   // return new Promise(async (resolve, reject) => {
   var _ds = SESSION_OBJ[SESSION_ID].DS_GLB[dataSourceSession];
   var args = _ds.args;
@@ -3262,20 +3268,7 @@ func.datasource.run_events_functions = async function (
   if (job_promises.length) {
     await Promise.all(job_promises)
   }
-  // console.log(job_promises)
-  // resolve()
 
-  // if (job_promises.length) {
-  //   Promise.all(job_promises)
-  //     .then((e) => {
-  //       resolve()
-  //     });
-
-  // } else {
-  //   resolve()
-  // }
-
-  // })
 
 };
 
@@ -4101,11 +4094,15 @@ func.datasource.del = function (SESSION_ID, dsP) {
 func.datasource.update = async function (
   SESSION_ID,
   datasource_changes,
-  from_worker
+  update_local_scope_only
 ) {
   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(
@@ -4115,68 +4112,81 @@ func.datasource.update = async function (
       ).system_globals;
     }
 
-    const set_fieldComputed_dependencies = async function (dsNo, record_id, field_id, value) {
-      // check if field has fieldComputed property
-      const _progFields = await func.datasource.get_progFields(
-        SESSION_ID,
-        dataSource
-      );
+    const set_fieldComputed_dependencies = async function (dsNo, field_id, parent_ds) {
 
-      let propExpressions
-      for await (const val of _progFields) {
+      // 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;
+            const fieldId = val.data.field_id;
 
-        if (fieldId !== field_id) continue
-        if (val.data.type !== "virtual" || !val.props.fieldComputed) break
+            // if (fieldId !== field_id) continue
+            if (val.data.type !== "virtual" || !val.props.fieldComputed) continue
 
-        propExpressions = val.props?.propExpressions?.fieldValue
+            const _propExpressions = val.props?.propExpressions?.fieldValue
+            if (_propExpressions && JSON.stringify(_propExpressions).includes(field_id)) {
+              fieldComputed_propExpressions = _propExpressions
+              fieldComputed_id = fieldId
+            }
+          }
 
-      }
+          if (!fieldComputed_id) return
 
-      if (!propExpressions) return
 
-      let new_datasource_changes = {}
-      for (const _ds of _session.DS_GLB) {
-        if (_ds.parentDataSourceNo !== dsNo) continue
+          // 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 {
 
-        if (!new_datasource_changes[_ds.dsSession]) {
-          new_datasource_changes[_ds.dsSession] = {}
-        }
-        for (const row of _ds.data_feed?.rows || []) {
-          for (const [key, val] of Object.entries(row)) {
-            if (key !== field_id) return
-            try {
-              if (!new_datasource_changes[_ds.dsSession][row._ROWID]) {
-                new_datasource_changes[_ds.dsSession][row._ROWID] = {}
-              }
-              let ret = await func.expression.get(
-                SESSION_ID,
-                propExpressions,
-                dsNo,
-                "update",
-                row._ROWID
-              );
-              new_datasource_changes[_ds.dsSession][row._ROWID][field_id] = ret.result
-              // const row_idx = func.common.find_ROWID_idx(_ds, record_id);
+                let ret = await func.expression.get(
+                  SESSION_ID,
+                  fieldComputed_propExpressions,
+                  dsNo,
+                  "update",
+                  row._ROWID
+                );
 
-              // _ds.data_feed.rows[row_idx][field_id] = ret.result;
-            } catch (err) {
-              console.error(err);
+                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)
       }
-      debugger
-      await func.datasource.update(SESSION_ID,
-        new_datasource_changes,
-        from_worker)
 
     }
 
     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
@@ -4205,12 +4215,51 @@ func.datasource.update = async function (
             try {
               const row_idx = func.common.find_ROWID_idx(_ds, record_id);
               _ds.data_feed.rows[row_idx][field_id] = value;
+              await set_fieldComputed_dependencies(dataSource, field_id, null)
+
+              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;
+                  }
+                }
+              }
             } catch (err) {
               console.error(err);
             }
 
-
-
             if (!fields_changed.includes(field_id)) {
               fields_changed.push(field_id);
             }
@@ -4221,102 +4270,45 @@ func.datasource.update = async function (
             _ds.currentRecordId = record_id;
           }
 
-          if (!from_worker) {
-            if (glb.IS_WORKER) {
-              let tree_ret = await func.utils.TREE_OBJ.get(SESSION_ID, _ds.prog_id);
 
-              if (tree_ret.menuType === "globals") {
-
-                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) {
-                  delete datasource_changes[dataSource][record_id][field_id]
-                }
-
-                if (record_id === "data_system") {
-                  delete datasource_changes[dataSource][record_id]
-                }
-              }
-            }
-          }
         }
         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);
+      }
 
 
 
-      }
 
-      if (!from_worker) {
-        if (glb.IS_WORKER) {
-          let tree_ret = await func.utils.TREE_OBJ.get(SESSION_ID, _ds.prog_id);
-          let server_field = false
-          // if (tree_ret.menuType === "globals") {
 
-          //   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
-          //   );
-          //   server_field = view_field_obj.serverField
-          // }
+    }
 
+    if (glb.IS_WORKER) {
 
-          if (_session.IS_API || typeof IS_MASTER_WEBSOCKET !== "undefined" || typeof IS_PROCESS_SERVER !== "undefined") {
-            continue;
-          }
+      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
+        );
 
-          if (tree_ret.menuType !== "component" && tree_ret.menuType !== "globals") {
-            // if (tree_ret.menuType !== "globals" || server_field) {
-            continue;
-            // }
-          }
-          // debugger;
-          // update client
+      }
 
-          func.utils.post_back_to_client(
-            SESSION_ID,
-            "update_client_eventChangesResults_from_worker",
-            _session.worker_id,
-            datasource_changes
-          );
-          return resolve();
-        }
+    } else {
+      if (!update_local_scope_only && !_.isEmpty(server_datasource_changes)) {
 
-        if (!glb.IS_WORKER) {
-          if (_ds._run_at !== "client" || _ds.tree_obj.menuType === "globals") {
-            // no need to update worker
-            // return resolve();
-            // continue;
-            // }
-
-            const ret = await func.index.call_worker(SESSION_ID, {
-              service: "update_datasource_changes_from_client",
-              data: {
-                session_id: SESSION_ID,
-                datasource_changes,
-              },
-              id: _ds.worker_id,
-            });
-          }
-        }
+        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,
+        });
       }
-    }
-    if (!glb.IS_WORKER) {
       ///// REFRESH SCREEN
       if (fields_changed.length) {
         await func.UI.screen.refresh_xu_attributes(SESSION_ID, fields_changed);
@@ -4328,13 +4320,246 @@ func.datasource.update = async function (
         );
       }
     }
-    return resolve();
+    resolve();
   });
+
 };
 
 
+// func.datasource.update = async function (
+//   SESSION_ID,
+//   datasource_changes,
+//   update_local_scope_only
+// ) {
+//   return new Promise(async (resolve, reject) => {
+//     var _session = SESSION_OBJ[SESSION_ID];
+
+//     if (typeof glb.GLOBAL_VARS === "undefined") {
+//       glb.GLOBAL_VARS = (
+//         await func.common.get_module(
+//           SESSION_ID,
+//           "xuda-system-globals-module.mjs"
+//         )
+//       ).system_globals;
+//     }
+
+//     let fieldComputed_datasource_changes = {};
+
+//     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 propExpressions
+//           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) break
+
+//             const _propExpressions = val.props?.propExpressions?.fieldValue
+//             if (_propExpressions && JSON.stringify(_propExpressions).includes(field_id)) {
+//               propExpressions = _propExpressions
+//             }
+//           }
+
+//           if (!propExpressions) return
+
+//           if (!fieldComputed_datasource_changes[dsSession]) {
+//             fieldComputed_datasource_changes[dsSession] = {}
+//           }
+//           // iterate ds rows
+//           for (const row of _ds.data_feed?.rows || []) {
+//             // iterate row fields
+//             for (const [key, val] of Object.entries(row)) {
+//               if (key !== field_id) return
+//               try {
+//                 if (!fieldComputed_datasource_changes[dsSession][row._ROWID]) {
+//                   fieldComputed_datasource_changes[dsSession][row._ROWID] = {}
+//                 }
+//                 let ret = await func.expression.get(
+//                   SESSION_ID,
+//                   propExpressions,
+//                   dsNo,
+//                   "update",
+//                   row._ROWID
+//                 );
+//                 fieldComputed_datasource_changes[dsSession][row._ROWID][field_id] = ret.result
+//                 // const row_idx = func.common.find_ROWID_idx(_ds, record_id);
+
+//                 // _ds.data_feed.rows[row_idx][field_id] = ret.result;
+//               } catch (err) {
+//                 console.error(err);
+//               }
+//             }
+//           }
+//         }
+//         await set_fieldComputed_dependencies(dsNo, field_id, dsSession)
+//       }
+//       debugger
+
+
+
+//     }
+
+//     var fields_changed = [];
+//     var datasource_changed = [];
+//     let client_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;
+//       }
+//       // 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);
+//             continue;
+//           }
+
+//           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);
+//               _ds.data_feed.rows[row_idx][field_id] = value;
+//               await set_fieldComputed_dependencies(dataSource, field_id, null)
+//             } catch (err) {
+//               console.error(err);
+//             }
+
+
+
+//             if (!fields_changed.includes(field_id)) {
+//               fields_changed.push(field_id);
+//             }
+//             if (!datasource_changed.includes(dataSource)) {
+//               datasource_changed.push(dataSource);
+//             }
+//           } else if (fields_data === "set") {
+//             _ds.currentRecordId = record_id;
+//           }
+
+//           if (!update_local_scope_only) {
+//             if (glb.IS_WORKER) {
+//               let tree_ret = await func.utils.TREE_OBJ.get(SESSION_ID, _ds.prog_id);
+
+//               if (tree_ret.menuType === "globals") {
+
+//                 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) {
+//                   delete datasource_changes[dataSource][record_id][field_id]
+//                 }
+
+//                 if (record_id === "data_system") {
+//                   delete datasource_changes[dataSource][record_id]
+//                 }
+//               }
+//             }
+//           }
+//         }
+//         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);
+//       }
+
+
+//       let new_datasource_changes = { ...datasource_changes, ...fieldComputed_datasource_changes }
+
+//       if (!update_local_scope_only) {
+//         if (glb.IS_WORKER) {
+//           let tree_ret = await func.utils.TREE_OBJ.get(SESSION_ID, _ds.prog_id);
 
 
+//           if (_session.IS_API || typeof IS_MASTER_WEBSOCKET !== "undefined" || typeof IS_PROCESS_SERVER !== "undefined") {
+//             continue;
+//           }
+
+//           if (tree_ret.menuType !== "component" && tree_ret.menuType !== "globals") {
+
+//             continue;
+
+//           }
+
+//           // update client
+
+//           func.utils.post_back_to_client(
+//             SESSION_ID,
+//             "update_client_eventChangesResults_from_worker",
+//             _session.worker_id,
+//             new_datasource_changes
+//           );
+//           return resolve();
+//         }
+
+//         if (!glb.IS_WORKER) {
+//           if (_ds._run_at !== "client" || _ds.tree_obj.menuType === "globals") {
+//             // no need to update worker
+//             // return resolve();
+//             // continue;
+//             // }
+
+//             const ret = await func.index.call_worker(SESSION_ID, {
+//               service: "update_datasource_changes_from_client",
+//               data: {
+//                 session_id: SESSION_ID,
+//                 new_datasource_changes,
+//               },
+//               id: _ds.worker_id,
+//             });
+//           }
+//         }
+//       }
+//     }
+//     if (!glb.IS_WORKER) {
+//       ///// REFRESH SCREEN
+//       if (fields_changed.length) {
+//         await func.UI.screen.refresh_xu_attributes(SESSION_ID, fields_changed);
+//         await func.UI.screen.refresh_screen(
+//           SESSION_ID,
+//           fields_changed,
+//           null,
+//           datasource_changed[0] // refresh the current datasource only
+//         );
+//       }
+//     }
+//     return resolve();
+//   });
+// };
+
 func.datasource.callback = function (
   SESSION_ID,
   dsSessionP,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@xuda.io/xuda-worker-bundle-min",
-  "version": "1.3.1185",
+  "version": "1.3.1187",
   "description": "xuda framework min",
   "main": "index.js",
   "scripts": {