@xuda.io/xuda-worker-bundle 1.3.1247 → 1.3.1249

package/index.js

@@ -4101,11 +4101,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,76 +4119,82 @@ func.datasource.update = async function (
       ).system_globals;
     }
 
-    const set_fieldComputed_dependencies = async function (dsNo, field_id, value) {
+    let fieldComputed_datasource_changes = {};
 
+    const set_fieldComputed_dependencies = async function (dsNo, field_id, parent_ds) {
 
-      let new_datasource_changes = {};
       // iterate child ds
-      for (const [key, _ds] of Object.entries(_session.DS_GLB)) {
-        if (_ds.parentDataSourceNo !== dsNo) continue
+      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;
 
-        // check if field has fieldComputed property
-        const _progFields = await func.datasource.get_progFields(
-          SESSION_ID,
-          _ds.dsSession
-        );
-        // find if field is computed
-        let propExpressions
-        for await (const val of _progFields) {
+            if (fieldId !== field_id) continue
+            if (val.data.type !== "virtual" || !val.props.fieldComputed) break
 
-          const fieldId = val.data.field_id;
+            const _propExpressions = val.props?.propExpressions?.fieldValue
+            if (_propExpressions && JSON.stringify(_propExpressions).includes(field_id)) {
+              propExpressions = _propExpressions
+            }
+          }
 
-          if (fieldId !== field_id) continue
-          if (val.data.type !== "virtual" || !val.props.fieldComputed) break
+          if (!propExpressions) return
 
-          const _propExpressions = val.props?.propExpressions?.fieldValue
-          if (_propExpressions && JSON.stringify(_propExpressions).includes(field_id)) {
-            propExpressions = _propExpressions
+          if (!fieldComputed_datasource_changes[dsSession]) {
+            fieldComputed_datasource_changes[dsSession] = {}
           }
-        }
-
-        if (!propExpressions) 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 !== 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);
 
-        if (!new_datasource_changes[_ds.dsSession]) {
-          new_datasource_changes[_ds.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 (!new_datasource_changes[_ds.dsSession][row._ROWID]) {
-                new_datasource_changes[_ds.dsSession][row._ROWID] = {}
+                // _ds.data_feed.rows[row_idx][field_id] = ret.result;
+              } catch (err) {
+                console.error(err);
               }
-              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);
-
-              // _ds.data_feed.rows[row_idx][field_id] = ret.result;
-            } 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
@@ -4213,13 +4223,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, 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);
             }
@@ -4230,102 +4278,80 @@ 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);
+      }
 
 
+      // let new_datasource_changes = { ...datasource_changes, ...fieldComputed_datasource_changes }
 
-      }
 
-      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") {
+    }
+    // if (!update_local_scope_only) {
+    //   if (glb.IS_WORKER) {
+    //     let tree_ret = await func.utils.TREE_OBJ.get(SESSION_ID, _ds.prog_id);
 
-          //   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 (_session.IS_API || typeof IS_MASTER_WEBSOCKET !== "undefined" || typeof IS_PROCESS_SERVER !== "undefined") {
-            continue;
-          }
 
-          if (tree_ret.menuType !== "component" && tree_ret.menuType !== "globals") {
-            // if (tree_ret.menuType !== "globals" || server_field) {
-            continue;
-            // }
-          }
-          // debugger;
-          // update client
+    //     // update client
 
-          func.utils.post_back_to_client(
-            SESSION_ID,
-            "update_client_eventChangesResults_from_worker",
-            _session.worker_id,
-            datasource_changes
-          );
-          return resolve();
-        }
+    //     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) {
+
+      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 (!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,
-            });
-          }
-        }
       }
-    }
-    if (!glb.IS_WORKER) {
+
+    } 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,
+            server_datasource_changes,
+          },
+          id: _ds.worker_id,
+        });
+      }
       ///// REFRESH SCREEN
       if (fields_changed.length) {
         await func.UI.screen.refresh_xu_attributes(SESSION_ID, fields_changed);
@@ -4337,12 +4363,245 @@ 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,

package/package.json

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