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

package/index.js

@@ -3243,9 +3243,9 @@ func.datasource.run_events_functions = async function (
 
 
     }
-    if (job_promises.length) {
-      await Promise.all(job_promises)
-    }
+    // if (job_promises.length) {
+    //   await Promise.all(job_promises)
+    // }
     resolve()
 
   })
@@ -4012,1299 +4012,7 @@ func.datasource.del = function (SESSION_ID, dsP) {
           RUNTIME_SERVER_WEBSOCKET_CONNECTED &&
           (!_session.opt.app_computing_mode ||
             _session.opt.app_computing_mode === "server")
-        ) {
-          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 = {};
 
 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.1221",
+  "version": "1.3.1222",
   "description": "xuda framework",
   "main": "index.js",
   "scripts": {