@xuda.io/xuda-worker-bundle 1.3.1222 → 1.3.1224

package/index.js

@@ -3243,10 +3243,15 @@ func.datasource.run_events_functions = async function (
 
 
     }
-    // if (job_promises.length) {
-    //   await Promise.all(job_promises)
-    // }
-    resolve()
+    if (job_promises.length) {
+      Promise.all(job_promises)
+        .then((e) => {
+          resolve()
+        });
+
+    } else {
+      resolve()
+    }
 
   })
 
@@ -4012,7 +4017,1299 @@ func.datasource.del = function (SESSION_ID, dsP) {
           RUNTIME_SERVER_WEBSOCKET_CONNECTED &&
           (!_session.opt.app_computing_mode ||
             _session.opt.app_computing_mode === "server")
-      func.utils = {};
+        ) {
+          WEB_WORKER[SESSION_ID][_ds.worker_id].emit("message", {
+            service: "close_websocket",
+          });
+        } else {
+          WEB_WORKER[SESSION_ID][_ds.worker_id].worker.terminate();
+        }
+
+        delete WEB_WORKER[SESSION_ID][_ds.worker_id];
+      } else {
+        const json = await func.index.call_worker(SESSION_ID, {
+          service: "datasource_delete",
+          data: data,
+          id: _ds.worker_id,
+        });
+        response.success(json, true);
+      }
+      if (DS_UI_EVENTS_GLB) delete DS_UI_EVENTS_GLB[dsP];
+    }
+    delete SESSION_OBJ[SESSION_ID].DS_GLB[dsP];
+  };
+
+  var delete_pending_jobs = function () {
+    var arr = [];
+    _.forEach(SESSION_OBJ[SESSION_ID].WORKER_OBJ.jobs, function (val, key) {
+      if (val && val.dsSessionP == dsP) {
+        arr.push(key);
+        for (const [key, val] of Object.entries($(".screen_blocker"))) {
+          $(val).remove();
+        }
+      }
+    });
+    for (let val of arr.reverse()) {
+      SESSION_OBJ[SESSION_ID].WORKER_OBJ.jobs.splice(val, 1);
+    }
+    if (!SESSION_OBJ[SESSION_ID].WORKER_OBJ.jobs.length)
+      SESSION_OBJ[SESSION_ID].WORKER_OBJ.stat = null;
+  };
+  if (!glb.IS_WORKER) {
+    if (SESSION_OBJ[SESSION_ID].DS_GLB[dsP]) {
+      delete SCREEN_BLOCKER_OBJ[
+        SESSION_OBJ[SESSION_ID].DS_GLB[dsP].screenId +
+        "_" +
+        SESSION_OBJ[SESSION_ID].DS_GLB[dsP].callingScreenId
+      ];
+
+      delete_pending_jobs();
+    }
+    if ($(SESSION_OBJ[SESSION_ID].root_element).find("xu-nav").length) {
+      var ds_obj = $(SESSION_OBJ[SESSION_ID].root_element)
+        .find("xu-nav")
+        ?.data()?.xuData.nav_params;
+      if (ds_obj) {
+        delete ds_obj[dsP];
+      }
+    }
+  }
+  perform_delete();
+};
+func.datasource.update = async function (
+  SESSION_ID,
+  datasource_changes,
+  from_worker
+) {
+  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;
+    }
+    var fields_changes = [];
+    var datasource_changed = [];
+    for await (const [dataSource, row_data] of Object.entries(
+      datasource_changes
+    )) {
+      var _ds = _session.DS_GLB[dataSource];
+      if (!_ds) {
+        continue;
+      }
+
+      for (const [record_id, fields_data] of Object.entries(row_data)) {
+        for (const [field_id, value] of Object.entries(fields_data)) {
+          if (record_id === "datasource_main") {
+            // _ds[field_id] = value;
+            _.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;
+            } catch (err) {
+              console.error(err);
+            }
+
+
+
+            if (!fields_changes.includes(field_id)) {
+              fields_changes.push(field_id);
+            }
+            if (!datasource_changed.includes(dataSource)) {
+              datasource_changed.push(dataSource);
+            }
+          } else if (fields_data === "set") {
+            _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_changed[dataSource][record_id][field_id]
+                }
+
+                if (record_id === "data_system") {
+                  delete datasource_changed[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 (_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
+
+          func.utils.post_back_to_client(
+            SESSION_ID,
+            "update_client_eventChangesResults_from_worker",
+            _session.worker_id,
+            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,
+                datasource_changes,
+              },
+              id: _ds.worker_id,
+            });
+          }
+        }
+      }
+    }
+    if (!glb.IS_WORKER) {
+      ///// REFRESH SCREEN
+      if (fields_changes.length) {
+        await func.UI.screen.refresh_xu_attributes(SESSION_ID, fields_changes);
+        await func.UI.screen.refresh_screen(
+          SESSION_ID,
+          fields_changes,
+          null,
+          datasource_changed[0] // refresh the current datasource only
+        );
+      }
+    }
+    return resolve();
+  });
+};
+
+func.datasource.callback = function (
+  SESSION_ID,
+  dsSessionP,
+  na,
+  rowIdP,
+  jobNoP,
+  NA_callingDataSourceP,
+  NA_isInitP,
+  nodeIdP
+) {
+  var _session = SESSION_OBJ[SESSION_ID];
+  var _ds = _session.DS_GLB[dsSessionP];
+
+  try {
+    const row_idx = func.common.find_ROWID_idx(_ds, "dataset");
+
+    if (_ds.PARAM_OUT_INFO) {
+      // write log for out params
+      for (const [key, val] of Object.entries(_ds.PARAM_OUT_INFO)) {
+        if (
+          typeof _ds?.data_feed?.rows?.[row_idx]?.[val.fieldId] === "undefined"
+        ) {
+          // func.utils.debug.log(SESSION_ID, key, val);
+          func.utils.alerts.invoke(
+            SESSION_ID,
+            "system_msg",
+            "SYS_MSG_0310",
+            val.fieldId,
+            dsSessionP
+          );
+          break;
+        }
+        val.result = _ds.data_feed.rows[row_idx][val.fieldId];
+      }
+    }
+  } catch (err) {
+    // console.error(err);
+  }
+
+  func.utils.debug.log(SESSION_ID, nodeIdP, {
+    module: _ds.viewModule,
+    action: "close",
+    source: _ds.viewSourceDesc,
+    type: "adapter",
+    prog_id: _ds.prog_id,
+    dsSession: dsSessionP,
+    prop: _ds.log_prop + " " + "adapter",
+  });
+  if (!glb.IS_WORKER) $(_session.root_element).css("cursor", "default");
+
+  if (_ds.prog_id) {
+    let _ds = _session.DS_GLB[dsSessionP];
+
+    func.utils.debug.watch(
+      SESSION_ID,
+      _ds.prog_id,
+      "program",
+      {
+        in_parameters: _ds.in_parameters,
+        out_parameters: _ds.out_parameters,
+        data_feed: _ds.data_feed,
+      },
+      _ds.tree_obj.menuType
+    );
+  }
+  delete _ds.old_dataSource;
+
+
+
+  return {
+    SESSION_ID,
+    dsSessionP,
+    rowIdP,
+    jobNoP,
+    callingLogId: _ds.callingLogId,
+    calling_jobP: _ds.calling_jobP,
+  };
+};
+func.datasource.validate_viewRange = async function (
+  SESSION_ID,
+  viewRangeExpP,
+  dsSessionP,
+  rowIdP,
+  sourceP
+) {
+  var _ds = SESSION_OBJ[SESSION_ID].DS_GLB[dsSessionP];
+  if (viewRangeExpP && _ds) {
+    var ret = func.expression.remove_quotes(
+      await func.expression.get(
+        SESSION_ID,
+        viewRangeExpP,
+        dsSessionP,
+        "range",
+        rowIdP
+      )
+    );
+    ret.result = func.expression.remove_quotes(ret.result);
+    func.utils.debug.log(SESSION_ID, _ds.prog_id, {
+      module: _ds.viewModule,
+      action: "range Exp",
+      prop: sourceP,
+      details: viewRangeExpP,
+      result: ret.result,
+      error: ret.error,
+      source: _ds.viewSourceDesc,
+      json: ret.explain,
+      fields: ret.fields,
+      dsSession: dsSessionP,
+    });
+    _ds.viewRangeExpResults = ret.fields;
+    if (glb.DEBUG_MODE) {
+      if (!_ds.debug) {
+        _ds.debug = {};
+      }
+      if (!_ds.debug.viewRangeExp) {
+        _ds.debug.viewRangeExp = [];
+      }
+      _ds.debug.viewRangeExp.push(ret);
+    }
+    return ret.result;
+  } else return false;
+};
+func.datasource.validate_viewLocate = async function (
+  SESSION_ID,
+  viewLocateExpP,
+  dsSessionP,
+  rowIdP,
+  sourceP
+) {
+  if (viewLocateExpP && _ds) {
+    var ret = func.expression.remove_quotes(
+      await func.expression.get(
+        SESSION_ID,
+        viewLocateExpP,
+        dsSessionP,
+        "locate",
+        rowIdP
+      )
+    );
+    ret.result = func.expression.remove_quotes(ret.result);
+    func.utils.debug.log(SESSION_ID, _ds.prog_id, {
+      module: _ds.viewModule,
+      action: "locate Exp",
+      prop: sourceP,
+      details: viewLocateExpP,
+      result: ret.result,
+      error: ret.error,
+      source: _ds.viewSourceDesc,
+      json: ret.explain,
+      fields: ret.fields,
+      dsSession: dsSessionP,
+    });
+    _ds.viewLocateExpResults = ret.fields;
+    return ret.result;
+  } else return false;
+};
+
+func.datasource.get_viewFields_for_update_function = function (
+  SESSION_ID,
+  calling_trigger_prop,
+  na,
+  dsSessionP
+) {
+  var viewFields = [];
+
+  var exp = calling_trigger_prop?.data?.name?.value;
+  if (!exp) {
+    return viewFields;
+  }
+  try {
+    // parse json
+    var json = JSON5.parse(exp.replace(/\n/gi, ""));
+    for (const [key, val] of Object.entries(json)) {
+      let id = key.substr(1, key.length - 1);
+      if (!id) continue;
+      viewFields.push({
+        val,
+        id,
+      });
+    }
+    return viewFields;
+  } catch (e) {
+    if (!exp) {
+      return;
+    }
+    if (exp.substr(exp.length - 1, 1) === ";")
+      exp = exp.substr(0, exp.length - 1); // remove closing if exist;
+    var exp_arr = exp.split(/;\s*(?=(?:[^"]|"[^"]*")*$)/g); // split ; outside quotes
+    if (exp_arr?.length) {
+      for (let val of exp_arr) {
+        // run view fields
+        var pos = val.indexOf(":");
+        var seg = [val.substring(0, pos), val.substring(pos + 1)];
+        if (seg && seg.length === 2) {
+          let id = seg[0].substr(1, seg[0].length);
+          if (!id) continue;
+          viewFields.push({
+            id,
+            val: seg[1],
+            //  , props: {},
+          });
+        } else {
+          func.utils.debug.log(SESSION_ID, _ds.prog_id, {
+            module: _ds.viewModule,
+            action: "set",
+            prop: "parse update exp",
+            details: exp,
+            result: "",
+            error: "Invalid json; too many segments",
+            source: _ds.viewSourceDesc,
+            json: "",
+            fields: "",
+            dsSession: dsSessionP,
+          });
+        }
+      }
+    }
+
+    return viewFields;
+  }
+};
+func.datasource.get_value = async function (
+  SESSION_ID,
+  fieldIdP,
+  dsSessionP,
+  rowIdP,
+  org_dsSessionP
+) {
+  const return_value = async (field_id, value) => {
+    const _progFields = await func.datasource.get_progFields(
+      SESSION_ID,
+      dsSessionP
+    );
+    let view_field_obj = func.common.find_item_by_key(
+      _progFields,
+      "field_id",
+      field_id
+    );
+    var fieldType = view_field_obj?.props?.fieldType || "string";
+    var fieldProp = view_field_obj?.props;
+    let table_field_obj;
+    if (view_field_obj?.data?.type === "table") {
+      if (!_ds._dataSourceTableId) {
+        return func.utils.debug_report(
+          SESSION_ID,
+          "Datasource",
+          `Table type defined without dataSourceTableId deceleration`,
+          "E"
+        );
+      }
+
+      let table_obj = await func.utils.FILES_OBJ.get(
+        SESSION_ID,
+        _ds._dataSourceTableId
+      );
+
+      if (!table_obj) {
+        return func.utils.debug_report(
+          SESSION_ID,
+          "Datasource",
+          `dataSourceTableId reference error: ` + _ds._dataSourceTableId,
+          "E"
+        );
+      }
+      table_field_obj = func.common.find_item_by_key(
+        table_obj.tableFields,
+        "field_id",
+        field_id
+      );
+      fieldType = table_field_obj.props?.fieldType;
+      fieldProp = table_field_obj.props;
+    }
+
+    let ret = {
+      value: await func.common.get_cast_val(
+        SESSION_ID,
+        `datasource get value ${_ds.tree_obj.menuName}`,
+        fieldIdP,
+        fieldType,
+        value,
+        null
+      ),
+      type: fieldType,
+      prop: fieldProp,
+    };
+
+    if (ret.value && typeof ret.value === "string" && ret.type !== "exp") {
+      if (/"/.test(ret.value) && ret.value.indexOf("\\") === -1)
+        ret.value = ret.value.replace(/"/g, '"');
+    }
+
+    return {
+      ret,
+      dsSessionP,
+      fieldIdP: field_id,
+      currentRecordId: _ds.currentRecordId,
+      found: typeof value !== "undefined",
+    };
+  };
+  const return_dynamic_value = async (field_id, value) => {
+    let view_field_obj = _ds.dynamic_fields[field_id];
+    var fieldType = view_field_obj?.props?.fieldType || "string";
+    var fieldProp = view_field_obj?.props;
+
+    let ret = {
+      value: view_field_obj.value,
+      type: fieldType,
+      prop: fieldProp,
+    };
+
+    if (ret.value && typeof ret.value === "string" && ret.type !== "exp") {
+      if (/"/.test(ret.value) && ret.value.indexOf("\\") === -1)
+        ret.value = ret.value.replace(/"/g, '"');
+    }
+
+    return {
+      ret,
+      dsSessionP,
+      fieldIdP: field_id,
+      currentRecordId: _ds.currentRecordId,
+      found: typeof value !== "undefined",
+    };
+  };
+  const return_value_parameters = async (field_id, value) => {
+    let ret = {
+      value: await func.common.get_cast_val(
+        SESSION_ID,
+        "datasource get value",
+        fieldIdP,
+        value.type,
+        value.value,
+        null
+      ),
+      type: value.type,
+      prop: null,
+    };
+
+    if (ret.value && typeof ret.value === "string" && ret.type !== "exp") {
+      if (/"/.test(ret.value) && ret.value.indexOf("\\") === -1)
+        ret.value = ret.value.replace(/"/g, '"');
+      // if (/"/.test(ret.value) && ret.value.indexOf("\\") === -1)
+      //   ret.value = ret.value.replace(/"/g, '\\"');
+    }
+
+    return {
+      ret,
+      dsSessionP,
+      fieldIdP: field_id,
+      currentRecordId: _ds.currentRecordId,
+      found: typeof value !== "undefined",
+    };
+  };
+  const return_value_system = async (field_id, value) => {
+    let fieldType = glb.GLOBAL_VARS[field_id].type;
+    let fieldProp = null;
+
+    let ret = {
+      value: await func.common.get_cast_val(
+        SESSION_ID,
+        `datasource get value ${_ds.tree_obj.menuName}`,
+        field_id,
+        fieldType,
+        value,
+        null
+      ),
+      type: fieldType,
+      prop: fieldProp,
+    };
+
+    return {
+      ret,
+      dsSessionP,
+      fieldIdP: field_id,
+      currentRecordId: _ds.currentRecordId,
+      found: typeof value !== "undefined",
+    };
+  };
+  const search_in_parameters = async (field_id) => {
+    if (typeof _ds?.in_parameters?.[field_id]?.value !== "undefined") {
+      let ret = await return_value_parameters(
+        field_id,
+        _ds.in_parameters[field_id]
+      );
+      return ret;
+    }
+
+    if (typeof _ds.parentDataSourceNo !== "undefined") {
+      var org_dsSession = org_dsSessionP;
+      if (!org_dsSessionP) org_dsSession = dsSessionP;
+      if (recordId && recordId !== "newRecord") org_dsSession = null;
+
+      return await func.datasource.get_value(
+        SESSION_ID,
+        fieldIdP,
+        _ds.parentDataSourceNo,
+        recordId,
+        org_dsSession
+      );
+    }
+
+    return await return_value(field_id);
+  };
+
+  if (typeof glb.GLOBAL_VARS === "undefined") {
+    glb.GLOBAL_VARS = (
+      await func.common.get_module(SESSION_ID, "xuda-system-globals-module.mjs")
+    ).system_globals;
+  }
+
+  var _ds = SESSION_OBJ[SESSION_ID].DS_GLB[dsSessionP];
+  if (!_ds) {
+    if (dsSessionP > 0) {
+      // let prev_ds = dsSessionP - 1;
+      return await func.datasource.get_value(
+        SESSION_ID,
+        fieldIdP,
+        dsSessionP - 1,
+        rowIdP,
+        org_dsSessionP
+      );
+    }
+    return await return_value(fieldIdP);
+  } //console.error("error: datasource not exist: " + dsSessionP);
+
+  let recordId = rowIdP;
+  if (!recordId) {
+    recordId = _ds.currentRecordId;
+  }
+
+  if (glb.GLOBAL_VARS[fieldIdP]) {
+    if (!_ds.data_system) {
+      _ds.data_system = {};
+    }
+
+    if (dsSessionP > 0) {
+      _ds.data_system["SYS_STR_ACTIVE_ROW_ID"] = _ds.currentRecordId;
+      _ds.data_system["SYS_STR_PROG_DS_SESSION"] = dsSessionP;
+    }
+
+    // set system time
+    if (glb.SYS_DATE_ARR.includes(fieldIdP)) {
+      var _ds_0 = SESSION_OBJ[SESSION_ID].DS_GLB[0];
+
+      if (_ds_0) {
+        if (!_ds_0.data_system) {
+          _ds_0.data_system = {};
+        }
+        const ts = await func.utils.get_dateTime(SESSION_ID, "SYS_DATE_VALUE");
+        for (const val of glb.SYS_DATE_ARR) {
+          _ds_0.data_system[val] = await func.utils.get_dateTime(
+            SESSION_ID,
+            val,
+            ts
+          );
+        }
+      }
+    }
+
+    // await func.datasource.set_system_vars(SESSION_ID, dsSessionP);
+    if (typeof _ds?.data_system?.[fieldIdP] !== "undefined") {
+      return await return_value_system(fieldIdP, _ds?.data_system?.[fieldIdP]);
+    }
+    return await search_in_parameters(fieldIdP);
+  }
+
+  // if (glb.PROTECTED_VARS[fieldIdP]) {
+  //   switch (fieldIdP) {
+  //     case "_ROW_NO": {
+  //       let row_no = Object.keys(_ds?.data_feed?.rows).indexOf(recordId) || 0;
+  //       return await return_value(fieldIdP, row_no);
+  //     }
+  //     default:
+  //       break;
+  //   }
+  // }
+
+  if (!_ds.data_feed) {
+    return await search_in_parameters(fieldIdP);
+  }
+
+  var _field_id = fieldIdP;
+
+  if (fieldIdP.substr(0, 1) === "_") {
+    if (_ds.alias) _field_id = _ds.alias[fieldIdP];
+  }
+
+  if (!org_dsSessionP && recordId) {
+    try {
+      const row_idx = func.common.find_ROWID_idx(_ds, recordId);
+      if (typeof _ds.data_feed?.rows?.[row_idx]?.[_field_id] !== "undefined") {
+        if (
+          Object.keys(_ds.data_feed?.rows?.[row_idx] || {})?.includes(_field_id)
+        ) {
+          return await return_value(
+            _field_id,
+            _ds.data_feed.rows[row_idx][_field_id]
+          );
+        }
+
+        if (Object.keys(_ds?.dynamic_fields || {})?.includes(_field_id)) {
+          return await return_dynamic_value(
+            _field_id,
+            _ds.dynamic_fields[_field_id]
+          );
+        }
+      }
+    } catch (err) {
+      // console.error(err);
+    }
+  }
+
+  try {
+    const row_idx = func.common.find_ROWID_idx(_ds, _ds.currentRecordId);
+
+    if (typeof _ds.data_feed?.rows?.[row_idx]?.[_field_id] !== "undefined") {
+      return await return_value(
+        _field_id,
+        _ds.data_feed.rows[row_idx][_field_id]
+      );
+    }
+  } catch (error) { }
+
+  if (typeof _ds?.dynamic_fields?.[_field_id] !== "undefined") {
+    return await return_dynamic_value(_field_id, _ds.dynamic_fields[_field_id]);
+  }
+
+  return await search_in_parameters(fieldIdP);
+};
+
+func.datasource.find_event_dataSource = async function (
+  SESSION_ID,
+  eventIdP,
+  dsSessionP
+) {
+  const _ds = SESSION_OBJ[SESSION_ID].DS_GLB[dsSessionP];
+  var ret;
+  //============================
+  // Search in given datasource
+  //============================
+  if (_ds?.prog_id) {
+    let view_ret = await func.utils.VIEWS_OBJ.get(SESSION_ID, _ds.prog_id);
+    if (
+      view_ret?.progEvents &&
+      func.common.find_item_by_key(view_ret.progEvents, "event_name", eventIdP)
+    ) {
+      ret = dsSessionP;
+      if (_ds.callingSource === "system") ret = 0;
+      if (_ds.callingSource === "program" || !_ds.callingSource)
+        ret = dsSessionP;
+      // >>> found value
+      return ret;
+    }
+  }
+  if (!ret && dsSessionP !== 0) {
+    //=======================================
+    // continue Search in parent datasource
+    //=======================================
+    if (
+      _ds &&
+      _ds.parentDataSourceNo &&
+      Number(_ds.parentDataSourceNo) > 0 &&
+      Number(_ds.parentDataSourceNo) < dsSessionP
+    ) {
+      return await func.datasource.find_event_dataSource(
+        SESSION_ID,
+        eventIdP,
+        _ds.parentDataSourceNo
+      );
+    } else {
+      //========================================
+      // continue Search in global system
+      //=========================================
+      if (!ret)
+        return await func.datasource.find_event_dataSource(
+          SESSION_ID,
+          eventIdP,
+          0
+        );
+    }
+  }
+};
+func.datasource.reset_jobs = function (SESSION_ID, dsSessionP, sourceP, errP) {
+  for (const [key, val] of Object.entries(
+    SESSION_OBJ[SESSION_ID].WORKER_OBJ.jobs
+  )) {
+    if (val.dsSessionP === dsSessionP) {
+      func.events.delete_job(SESSION_ID, val.job_num);
+      break;
+    }
+  }
+  func.utils.debug_report(
+    SESSION_ID,
+    sourceP + "Missing datasource: " + dsSessionP,
+    errP,
+    "W",
+    null
+  );
+};
+// func.datasource.set_system_vars = async function (SESSION_ID, dsSessionP) {
+//   var _ds = SESSION_OBJ[SESSION_ID].DS_GLB[dsSessionP];
+//   if (!_ds) return;
+
+//   if (!_ds.data_system) {
+//     _ds.data_system = {};
+//   }
+
+//   if (dsSessionP > 0) {
+//     _ds.data_system["SYS_STR_ACTIVE_ROW_ID"] = _ds.currentRecordId;
+//     _ds.data_system["SYS_STR_PROG_DS_SESSION"] = dsSessionP;
+//   }
+
+//   // _ds.data_system["SYS_OBJ_DS_INFO"] = {
+//   //   rows: _ds.rows_found,
+//   //   first_row_id: _ds.firstRecordId,
+//   //   last_row_id: _ds.lastRecordId,
+//   //   query_from_segments_json: _ds.filter_from,
+//   //   query_to_segments_json: _ds.filter_from,
+//   //   locate_query_from_segments_json: _ds.locate_from,
+//   //   locate_query_to_segments_json: _ds.locate_to,
+//   //   first_row_segments_json: _ds.firstRecordKey_object,
+//   //   last_row_segments_json: _ds.lastRecordKey_object,
+//   //   rowid: _ds.currentRecordId,
+//   // };
+
+//   // if (!_ds.data_system["SYS_OBJ_DS_DATA"] && dsSessionP == 0) {
+//   //   _ds.data_system["SYS_OBJ_DS_DATA"] = {
+//   //     value: _.cloneDeep(_ds.data_system),
+//   //   };
+//   // }
+//   var _ds_0 = SESSION_OBJ[SESSION_ID].DS_GLB[0];
+//   if (!_ds_0) return;
+
+//   if (!_ds_0.data_system) {
+//     _ds_0.data_system = {};
+//   }
+//   const ts = await func.utils.get_dateTime(SESSION_ID, "SYS_DATE_VALUE");
+//   for (const val of glb.SYS_DATE_ARR) {
+//     _ds_0.data_system[val] = await func.utils.get_dateTime(SESSION_ID, val, ts);
+//   }
+// };
+func.datasource.get_currentRecordId = function (
+  SESSION_ID,
+  dsSessionP,
+  from_datasourceP
+) {
+  var _ds = SESSION_OBJ[SESSION_ID].DS_GLB[dsSessionP];
+  if (_ds._dataSourceTableId !== "") {
+    var firstRecordId = _ds.firstRecordId; // returns the value of the fist row
+    var currentRecordId = _ds.currentRecordId; // record id that exist on ds after entering the form
+    var locatedRecordId = _ds.locatedRecordId; // record id located by ds
+    if (!currentRecordId || from_datasourceP) {
+      // first time without locate
+      if (!locatedRecordId) currentRecordId = firstRecordId;
+      // set first row when no rec located
+      else currentRecordId = locatedRecordId; // set with located row
+    }
+  } else currentRecordId = "newRecord"; // create mode
+  return currentRecordId;
+};
+func.datasource.interval = function (session_id, dsSessionP, typeP) {
+  var SESSION_ID = session_id;
+  var interval = [];
+  var _ds = SESSION_OBJ[SESSION_ID].DS_GLB[dsSessionP];
+  // var ds = _ds;
+  // var v = ds.v;
+  // var arr = func.datasource.get_event_interval_arr(
+  //   SESSION_ID,
+  //   dsSessionP,
+  //   typeP
+  // );
+  var arr = _ds[typeP];
+
+  var fx = {
+    init: async function () {
+      if (arr?.length) {
+        for (let val of arr) {
+          var event_id = val[0];
+          var interval_rate = val[1];
+          var condition = val[2];
+
+          interval.push(
+            setInterval(async function () {
+              if (!SESSION_OBJ[SESSION_ID]) return;
+              var event_count = await func.datasource.get_view_events_count(
+                SESSION_ID,
+                dsSessionP,
+                typeP,
+                event_id
+              );
+              if (!event_count) {
+                fx.clear();
+                return;
+              }
+              var event_condition = await func.expression.get(
+                SESSION_ID,
+                condition,
+                dsSessionP,
+                "condition"
+              ); // execute condition;
+              if (condition && !event_condition.result) return;
+
+              const e = await func.datasource.execute_view_events(
+                SESSION_ID,
+                dsSessionP,
+                typeP,
+                event_id
+              );
+              // for (const [key, val] of Object.entries(e)) {
+              //   val.done = false;
+              // }
+            }, Number(interval_rate) * 1000)
+          );
+        }
+      } else {
+        await fx.clear();
+        return;
+      }
+    },
+    clear: function () {
+      if (DATASOURCE_INTERVALS[session_id])
+        delete DATASOURCE_INTERVALS[session_id][dsSessionP];
+      for (const [key, val] of Object.entries(interval)) {
+        clearInterval(val);
+      }
+    },
+  };
+  return fx;
+};
+func.datasource.server_cron = function (session_id) {
+  var SESSION_ID = session_id;
+  var jobs = [];
+  // var ds = SESSION_OBJ[SESSION_ID].DS_GLB[0];
+  // var v = ds.v;
+  var arr = func.datasource.get_event_interval_arr(
+    SESSION_ID,
+    0,
+    "server_cron"
+  );
+  const schedule = require("node-schedule");
+
+  if (!arr.length) {
+    return jobs;
+  }
+  for (let val of arr) {
+    var event_id = val[0];
+    var cron_prop = val[1];
+    var condition = val[2];
+
+    jobs.push(
+      schedule.scheduleJob(cron_prop, async function () {
+        if (!SESSION_OBJ[SESSION_ID]) return;
+        var event_count = await func.datasource.get_view_events_count(
+          SESSION_ID,
+          0,
+          "server_cron",
+          event_id
+        );
+        if (!event_count) {
+          fx.clear();
+          return;
+        }
+        var event_condition = await func.expression.get(
+          SESSION_ID,
+          condition,
+          0,
+          "condition"
+        ); // execute condition;
+        if (condition && !event_condition.result) return;
+        if (event_count) {
+          const e = await func.datasource.execute_view_events(
+            SESSION_ID,
+            0,
+            "server_cron",
+            event_id
+          );
+          // for (const [key, val] of Object.entries(e)) {
+          //   val.done = false;
+          // }
+        }
+      })
+    );
+  }
+
+  return jobs;
+};
+func.datasource.get_viewLoops = async function (
+  SESSION_ID,
+  dataSourceSession,
+  data,
+  batch_source,
+  default_limit
+) {
+  var _ds = SESSION_OBJ[SESSION_ID].DS_GLB[dataSourceSession];
+  var args = _ds.args;
+  // var v = _ds.v;
+  var ret = default_limit;
+
+  if (batch_source === "db_data") ret = _.size(data.rows);
+  if (batch_source === "array" || batch_source === "csv") ret = data.length;
+  if (batch_source === "json") ret = Object.keys(data).length;
+  if (_ds.progDataSource?.dataSourceLimit) {
+    if (
+      batch_source !== "no_data" &&
+      Number(_ds.progDataSource?.dataSourceLimit) < ret
+    ) {
+      ret = Number(_ds.progDataSource.dataSourceLimit);
+    }
+    if (!batch_source) ret = Number(_ds.progDataSource.dataSourceLimit);
+  }
+  if (prog_obj.progDataSource?.dataSourceLoopExp) {
+    var n = (
+      await func.expression.get(
+        SESSION_ID,
+        _ds.v.viewLoopsExp,
+        dataSourceSession,
+        "view_loop",
+        args.rowIdP
+      )
+    ).result;
+    if (batch_source !== "no_data" && n < ret) ret = n;
+    if (!batch_source) ret = n;
+  }
+  return ret;
+};
+func.datasource.set_VIEW_data = async function (SESSION_ID, args, _ds) {
+  _ds.v = {
+    viewFieldsProp: {},
+    segFrom: [],
+    segTo: [],
+    segLocateFrom: [],
+    segLocateTo: [],
+    viewModule: "adapter",
+  };
+  _ds.viewEventExec_arr = {};
+
+  var view = _.cloneDeep(
+    await func.utils.VIEWS_OBJ.get(SESSION_ID, args.prog_id)
+  );
+
+  _ds.v.dataSourceSrcType = view.dataSourceSrcType;
+
+  if (view.progDataSource) _ds.progDataSource = view.progDataSource;
+
+  _ds.v.viewIndex = view?.progDataSource?.dataSourceIndexesObj;
+
+  let tree_ret = await func.utils.TREE_OBJ.get(SESSION_ID, args.prog_id);
+  _ds.v.viewSourceDesc = tree_ret.menuName;
+
+  if (!_ds.v.viewSourceDesc && tree_ret) {
+    _ds.v.viewSourceDesc = tree_ret.menuName;
+  }
+
+  if (glb.FUNCTION_NODES_ARR.includes(tree_ret.menuType)) {
+    _ds.v.viewModule = "function";
+  }
+  _ds.v.viewSourceProp = tree_ret.menuType;
+  if (view.progEvents) _ds.v.progEvents = view.progEvents;
+
+  _ds._progDataSource_fields = [];
+  if (_ds.progDataSource) {
+    let ret = func.expression.parse(JSON.stringify(_ds.progDataSource));
+    _ds._progDataSource_fields = ret.map((e) => {
+      if (e.fieldId) return e.fieldId;
+    });
+  }
+};
+
+func.datasource.get_cast_val = async function (
+  SESSION_ID,
+  source,
+  dsSession,
+  valP,
+  typeP,
+  req,
+  error
+) {
+  var prog_id, prog_name;
+  var _session = SESSION_OBJ[SESSION_ID];
+  var _ds = _session.DS_GLB[dsSession];
+
+  prog_id = _ds.prog_id;
+  prog_name = await func.utils.TREE_OBJ.get(SESSION_ID, _ds.prog_id).menuName;
+
+  const prog_info = prog_id ? ` (prog: ${prog_id} ${prog_name})` : "";
+
+  const report_conversion_error = function (res) {
+    var msg = `error converting from ${valP} to ${typeP}`;
+    if (error) {
+      return func.utils.debug_report(SESSION_ID, msg, "", "W");
+    }
+    func.utils.debug_report(
+      SESSION_ID,
+      msg + " " + _.capitalize(source) + prog_info,
+      "",
+      "E"
+    );
+  };
+  const report_conversion_warn = function (res) {
+    var msg = `type mismatch auto conversion from value ${valP} to ${typeP}`;
+    func.utils.debug_report(
+      SESSION_ID,
+      msg + " " + _.capitalize(source) + prog_info,
+      "",
+      "W"
+    );
+  };
+  // var ret = valP;
+  if (error) {
+    return report_conversion_error();
+  }
+
+  const module = await func.common.get_module(
+    SESSION_ID,
+    "xuda-get-cast-util-module.mjs"
+  );
+  return module.cast(
+    typeP,
+    valP,
+    report_conversion_error,
+    report_conversion_warn
+  );
+};
+func.datasource.get_field_init_triggers_to_run = function (
+  SESSION_ID,
+  dataSourceSession,
+  pre_init_fieldsP
+) {
+  var _ds = SESSION_OBJ[SESSION_ID].DS_GLB[dataSourceSession];
+  if (!_ds) return;
+
+  return []; // inactive 021617
+}; // inactive temporary, design to execute init triggers when querying large datasets
+func.datasource.get_pre_init_fields = function (
+  SESSION_ID,
+  dsSessionP,
+  viewRangeExpP,
+  viewSortExpP,
+  viewGroupByExpP,
+  viewLocateExpP
+) {
+  var ret = [];
+  return; // inactive 021617
+}; // temporary inactive, init preformed on the first round
+
+func.datasource.add_dynamic_field_to_ds = function (
+  SESSION_ID,
+  dsSessionP,
+  key,
+  val
+) {
+  var _ds = SESSION_OBJ[SESSION_ID].DS_GLB[dsSessionP];
+  if (!_ds.dynamic_fields) {
+    _ds.dynamic_fields = {};
+  }
+
+  const toType = function (obj) {
+    return {}.toString
+      .call(obj)
+      .match(/\s([a-zA-Z]+)/)[1]
+      .toLowerCase();
+  };
+
+  _ds.dynamic_fields[key] = {
+    id: crypto.randomUUID(),
+    data: {
+      type: "virtual",
+      field_id: key,
+    },
+    props: {
+      fieldType: val ? toType(val) : "string",
+    },
+    value: val,
+  };
+};
+
+func.datasource.get_progFields = async function (SESSION_ID, dsSessionP) {
+  var _ds = SESSION_OBJ[SESSION_ID].DS_GLB[dsSessionP];
+  const _view_obj = await func.utils.VIEWS_OBJ.get(SESSION_ID, _ds.prog_id);
+  return _view_obj.progFields;
+};
+func.datasource.update_changes_for_out_parameter = async function (
+  SESSION_ID,
+  dsSessionP,
+  calling_dsP
+) {
+  let _session = SESSION_OBJ[SESSION_ID];
+  let _ds = _session.DS_GLB[dsSessionP];
+  const _calling_ds = _session.DS_GLB[calling_dsP];
+  //
+  if (_ds.PARAM_OUT_INFO) {
+    let data = {};
+    for await (const [key, val] of Object.entries(_ds.PARAM_OUT_INFO)) {
+      if (val.prop === "out") {
+        try {
+          const row_idx = func.common.find_ROWID_idx(_ds, _ds.currentRecordId);
+          data[val.details] = _ds.data_feed.rows[row_idx][val.fieldId];
+        } catch (err) {
+          console.error(err);
+        }
+      }
+    }
+    if (!_.isEmpty(data)) {
+      let datasource_changes = {
+        [calling_dsP]: { [_calling_ds.currentRecordId]: data },
+      };
+      await func.datasource.update(SESSION_ID, datasource_changes);
+    }
+  }
+};
+
+func.datasource.set_outputField = async function (SESSION_ID, dsSessionP, result, args) {
+  var _session = SESSION_OBJ[SESSION_ID];
+  // let _ds = _session.DS_GLB[dsSessionP];
+
+
+  const output_field = await func.datasource.get_args_property_value(SESSION_ID, dsSessionP, args, "outputField")
+
+
+  if (output_field) {
+    let datasource_changes = {};
+
+    let ret_get_value = await func.datasource.get_value(
+      SESSION_ID,
+      output_field,
+      dsSessionP
+    );
+    if (ret_get_value.found) {
+      let _ds = _session.DS_GLB[ret_get_value.dsSessionP];
+      if (!datasource_changes[_ds.dsSession]) {
+        datasource_changes[_ds.dsSession] = {};
+      }
+      if (
+        !datasource_changes[_ds.dsSession][ret_get_value.currentRecordId]
+      ) {
+        datasource_changes[_ds.dsSession][ret_get_value.currentRecordId] =
+          {};
+      }
+      datasource_changes[_ds.dsSession][ret_get_value.currentRecordId][
+        output_field
+      ] = result;
+      await func.datasource.update(SESSION_ID, datasource_changes);
+    }
+  }
+
+}
+
+func.datasource.get_args_property_value = async function (SESSION_ID, dsSession, args, prop_name) {
+  let _prop = args?.calling_trigger_prop?.data?.name;
+  let _value = _prop[prop_name];
+  if (_prop?.[`xu-exp:${prop_name}`]) {
+    _value = (
+      await func.expression.get(
+        SESSION_ID,
+        _prop[`xu-exp:${prop_name}`],
+        dsSession,
+        `${prop_name} expression`
+      )
+    ).result;
+  }
+
+  return _value;
+};
+ func.utils = {};
 
 func.utils.debug = {};
 func.utils.debug.watch = async function (

package/package.json

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