@xuda.io/xuda-worker-bundle 1.3.852 → 1.3.854

package/index.js

@@ -2277,7 +2277,7 @@ func.datasource.execute = async function (
         null,
         _ds?.progDataSource?.sortModel
       );
-      debugger;
+
       const ret_rows_found = await func.db.get_query(
         SESSION_ID,
         _ds._dataSourceTableId,
@@ -2291,7 +2291,7 @@ func.datasource.execute = async function (
         true,
         null
       );
-      _ds.rows_found = ret_rows_found?.data?.[0]?.value || 0;
+      _ds.rows_found = ret_rows_found?.rows?.[0]?.value || 0;
       break;
 
     case "array": {
@@ -2591,7 +2591,7 @@ func.datasource.execute = async function (
     case "component":
       _ds.data_feed = { sort: {}, groupBy: {}, rows: {} };
 
-      _ds.rows_found = 0;
+      // _ds.rows_found = 0;
       _ds.rows_processed = 0;
       _ds.viewRangeExp_rows_deleted = 0;
 
@@ -3067,7 +3067,7 @@ func.datasource.run_rows_form = async function (
           idx,
           sort_index
         );
-        _ds.rows_found++;
+        // _ds.rows_found++;
       };
       const delete_row = async function () {
         if (_ds) {
@@ -3076,7 +3076,7 @@ func.datasource.run_rows_form = async function (
           if (!_ds.v.viewRangeExp_deleted) _ds.v.viewRangeExp_deleted = [];
           _ds.v.viewRangeExp_deleted.push(rowIdxP);
         }
-        _ds.rows_found--;
+        // _ds.rows_found--;
         _ds.viewRangeExp_rows_deleted++;
       };
       if (_ds.progDataSource?.dataSourceFiltersScript) {
@@ -3894,977 +3894,7 @@ func.datasource.callback = function (
     var a = array.concat();
     for (var i = 0; i < a.length; ++i) {
       for (var j = i + 1; j < a.length; ++j) {
-        if (a[i] === a[j]) a.splice(j--, 1);
-      }
-    }
-    return a;
-  }
-
-  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 = JSON.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) {
-    // if (typeof _ds.data_feed?.rows?.[recordId]?.[_field_id] !== "undefined") {
-    if (
-      Object.keys(_ds.data_feed?.rows?.[recordId] || {})?.includes(_field_id)
-    ) {
-      return await return_value(
-        _field_id,
-        _ds.data_feed.rows[recordId][_field_id]
-      );
-    }
-    // if (typeof _ds?.dynamic_fields?.[_field_id] !== "undefined") {
-    if (Object.keys(_ds?.dynamic_fields || {})?.includes(_field_id)) {
-      return await return_dynamic_value(
-        _field_id,
-        _ds.dynamic_fields[_field_id]
-      );
-    }
-  }
-
-  if (
-    typeof _ds.data_feed?.rows?.[_ds.currentRecordId]?.[_field_id] !==
-    "undefined"
-  ) {
-    return await return_value(
-      _field_id,
-      _ds.data_feed.rows[_ds.currentRecordId][_field_id]
-    );
-  }
-  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;
-  _ds.v.viewExitExp = view.dataSourceExitScript;
-
-  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.add_dynamic_field_to_data_feed = function (
-//   SESSION_ID,
-//   dsSessionP,
-//   key,
-//   val
-// ) {
-//   var _ds = SESSION_OBJ[SESSION_ID].DS_GLB[dsSessionP];
-//   if (!_ds.dynamic_fields) {
-//     _ds.dynamic_fields = [];
-//   }
-//   _ds.data_feed.rows[_ds.currentRecordId][key] = val;
-
-//   // todo: check duplicates
-//   if (_ds.dynamic_fields.some((e) => e.data.field_id === key)) return;
-
-//   const toType = function (obj) {
-//     return {}.toString
-//       .call(obj)
-//       .match(/\s([a-zA-Z]+)/)[1]
-//       .toLowerCase();
-//   };
-
-//   _ds.dynamic_fields.push({
-//     id: crypto.randomUUID(),
-//     data: {
-//       type: "virtual",
-//       field_id: key,
-//     },
-//     props: {
-//       fieldType: val ? toType(val) : "string",
-//     },
-//   });
-// };
-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;
-  // var ret_arr = _view_obj.progFields;
-
-  // _ds?.dynamic_fields?.forEach((field) => {
-  //   if (ret_arr.some((e) => e.data.field_id === field.data.field_id)) {
-  //     return;
-  //   }
-
-  //   ret_arr.push(field);
-  // });
-
-  // return ret_arr;
-};
- func.utils = {};
+        if (a[i] === a[j]) a.s 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.852",
+  "version": "1.3.854",
   "description": "xuda framework",
   "main": "index.js",
   "scripts": {