@xuda.io/xuda-dbs-plugin-xuda 1.0.47 → 1.0.49

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@xuda.io/xuda-dbs-plugin-xuda",
-  "version": "1.0.47",
+  "version": "1.0.49",
   "description": "Xuda Database Socket for Xuda's proprietary structure powered by CouchDB",
   "scripts": {
     "pub": "npm version patch --force && npm publish --access public"

package/server.js

@@ -70,7 +70,6 @@ const check_unique = async function (e, docP, table_obj, db, app_id_reference) {
       keyValue.join(",") +
       "]]";
     try {
-      // const json = await _this.runtime_xuda_driver("runtime_get_index", e);
       e.view = "db_index";
       const ret = await query_db(e, db, app_id_reference, table_obj);
       const json = ret.data;
@@ -1657,26 +1656,53 @@ exports.update = async (params, setup_doc, resolve, reject) => {
     const doc = await db.get(e.row_id, {});
     let data = doc.udfData.data;
     var error;
+    if (!e.field_id && !e.data) {
+      error = "Invalid field_id or data object to save";
+      return reject(error);
+    }
+    // single value save
+    if (e.field_id) {
+      let _tableFieldsObj = find_item_by_key(
+        table_obj.tableFields,
+        "field_id",
+        e.field_id
+      );
+      if (!_tableFieldsObj || _.isEmpty(_tableFieldsObj)) {
+        return reject("Error:" + e.field_id + " - field not found");
+      }
 
-    const _tableFieldsObj = find_item_by_key(
-      table_obj.tableFields,
-      "field_id",
-      e.field_id
-    );
-    if (!_tableFieldsObj || _.isEmpty(_tableFieldsObj)) {
-      return reject("Error:" + e.field_id + " - field not found");
+      data[e.field_id] = await get_cast_val(
+        "dbs_update",
+        e.field_id,
+        _tableFieldsObj.props.fieldType,
+        e.field_value
+      );
+    }
+    if (e.data) {
+      data = {};
+      for await (const [key, val] of Object.entries(e.data)) {
+        let _tableFieldsObj = find_item_by_key(
+          table_obj.tableFields,
+          "field_id",
+          key
+        );
+        if (!_tableFieldsObj || _.isEmpty(_tableFieldsObj)) {
+          reject("Error:" + key + " - field not found");
+          break;
+        }
+
+        data[key] = await get_cast_val(
+          "dbs_update",
+          key,
+          _tableFieldsObj.props.fieldType,
+          val
+        );
+      }
     }
 
-    data[e.field_id] = await get_cast_val(
-      "runtime_update_data",
-      e.field_id,
-      _tableFieldsObj.props.fieldType,
-      e.field_value
-    );
     if (error) {
       return reject(error);
     }
-
     doc.ts = Date.now();
     const index_ret = await get_index_json(doc, table_obj);
     if (index_ret.code < 0) {
@@ -1767,6 +1793,6 @@ exports.test_connection = async (params, setup_doc, resolve, reject) => {
     await nano.get("_design/xuda");
     resolve(nano);
   } catch (err) {
-    return reject(err);
+    return reject(err.message);
   }
 };

package/index.mjs

@@ -1,1061 +0,0 @@
-const check_unique = async function (docP, table_obj) {
-  var len = docP.udfIndex.length;
-  if (!len) {
-    return { code: -11, data: "table must have primary index" };
-  }
-  var found_unique;
-  var ret = { code: 1, data: "ok" };
-
-  for await (var val of docP.udfIndex) {
-    if (!table_obj.tableIndexes) {
-      ret = {
-        code: -14,
-        data: "table definition missing for: " + val.fileId,
-      };
-      break;
-    }
-
-    const table_index = find_item_by_key_root(
-      table_obj.tableIndexes,
-      "id",
-      val.indexId
-    );
-
-    if (!table_index) {
-      ret = {
-        code: -13,
-        data: "keys definition missing for Table: " + val.fileId,
-      };
-      break;
-    }
-
-    if (!table_index.data.unique) {
-      continue;
-    }
-    if (!table_index?.data?.keys || _.isEmpty(table_index.data.keys)) {
-      ret = {
-        code: -14,
-        data: "keys definition missing for index: " + val.indexId,
-      };
-      break;
-    }
-
-    var keysArr = table_index.data.keys;
-    var keyValue = [];
-
-    for await (const [keySegment, valSegment] of Object.entries(keysArr)) {
-      // run on key segment
-      let _fieldType = find_item_by_key(
-        table_obj.tableFields,
-        "field_id",
-        valSegment
-      ).props.fieldType;
-      let _val = await get_cast_val(
-        "check_unique",
-        valSegment,
-        _fieldType,
-        val.keyValue[keySegment]
-      );
-      keyValue.push(_val);
-    }
-
-    var key =
-      '["' +
-      val.fileId +
-      '","' +
-      val.indexId +
-      '",[' +
-      keyValue.join(",") +
-      "]]";
-    try {
-      // const json = await _this.runtime_xuda_driver("runtime_get_index", e);
-      e.view = "db_index";
-      const json = await _this.Read(_, e, db, app_id_reference, table_obj);
-
-      // var data;
-
-      if (json.code > 0) {
-        var data = json.data;
-        if (data?.rows?.length) {
-          for await (var val of data.rows) {
-            if (val.id !== docP._id) {
-              found_unique = true;
-            }
-          }
-          if (found_unique) {
-            throw "error checking unique:" + key;
-          }
-        }
-      }
-      // throw json.data;
-      return { code: 1, data: "ok" };
-    } catch (msg) {
-      console.error(msg);
-      ret = { code: -22, data: msg };
-      break;
-    }
-  }
-
-  return ret;
-};
-
-const get_index_json = async function (docInP, table_obj) {
-  try {
-    var keysArr = [];
-    var index_json = [];
-    var key_val = [];
-
-    if (docInP.udfData && table_obj) {
-      // check for udf data array
-      if (table_obj.tableIndexes) {
-        // console.log(udfDicIndexT.rows);
-        for await (var valIndex of table_obj.tableIndexes) {
-          // run on index rows
-          keysArr = valIndex.data.keys; // create array from keys string segment
-          key_val = [];
-          for await (var valSegment of keysArr) {
-            // run on key segment
-            // find keys values
-            if (docInP.udfData.data[valSegment]) {
-              key_val.push(docInP.udfData.data[valSegment]);
-              continue;
-            }
-            // put the value
-            // debugger;
-            const field_obj = find_item_by_key(
-              table_obj.tableFields,
-              "field_id",
-              valSegment
-            );
-            if (!field_obj) {
-              throw "field not found in key: " + valSegment;
-            }
-
-            let _val = await get_cast_val(
-              "get_index_json",
-              field_obj.id,
-              field_obj.props.fieldType,
-              null
-            );
-            key_val.push(_val);
-          }
-
-          index_json.push({
-            fileId: docInP.udfData.udffileid,
-            indexId: valIndex.id,
-            keySegments: keysArr,
-            keyValue: key_val,
-          });
-        }
-        // );
-      }
-    }
-    return { code: 1, data: index_json };
-  } catch (msg) {
-    return { code: -1, data: msg };
-  }
-};
-
-const find_item_by_key_root = function (arr, key, val) {
-  return _.find(arr, function (e) {
-    return e[key] === val;
-  });
-};
-
-export const Create = async (_, e, db, app_id_reference, table_obj) => {
-  const batch = async function () {
-    var docs = [];
-    try {
-      for await (var val of e.table_data) {
-        var doc = {
-          docType: "database",
-
-          user: e.uid,
-          stat: 3,
-          udfData: {
-            udffileid: e.table_id,
-            data: val,
-            error: {},
-          },
-
-          ts: new Date().valueOf(),
-          date: new Date().valueOf(),
-        };
-        const index_ret = await get_index_json(doc, table_obj);
-        if (index_ret < 0) throw index_ret.data;
-        doc.udfIndex = index_ret.data;
-
-        const ret = await check_unique(doc, table_obj);
-        if (ret.code < 0) {
-          throw ret;
-        }
-        docs.push(doc);
-      }
-      try {
-        const body = await db.bulk({ docs: docs });
-        return { code: 110, data: body };
-      } catch (error) {
-        return { code: -400, data: error };
-      }
-    } catch (msg) {
-      return { code: -400, data: msg };
-    }
-  };
-  const single = async function () {
-    var doc = {
-      docType: "database",
-
-      user: e.uid,
-      stat: 3,
-      udfData: {
-        udffileid: e.table_id,
-        data: e.table_data,
-        error: {},
-      },
-
-      ts: new Date().valueOf(),
-      date: new Date().valueOf(),
-    };
-    const index_ret = await get_index_json(doc, table_obj);
-    if (index_ret.code < 0) {
-      return index_ret;
-    }
-    doc.udfIndex = index_ret.data;
-    const ret = await check_unique(doc, table_obj);
-    if (ret.code < 0) {
-      return ret;
-    }
-    try {
-      const body = await db.insert(doc);
-      return { code: 110, data: body };
-    } catch (error) {
-      return { code: -400, data: error };
-    }
-  };
-  if (Array.isArray(e.table_data)) {
-    return await batch();
-  }
-  return await single();
-};
-export const Read = async (params, setup_doc, resolve, reject) => {
-  const e = params.e;
-  const db = params.db;
-  const app_id_reference = params.app_id_reference;
-  const table_obj = params.table_obj;
-
-  var key;
-
-  const runtime_get_mango_data = async function () {
-    const done = async function (body) {
-      const raw_data = async function () {
-        var rows = [];
-
-        for await (var val of body.docs) {
-          var data = {};
-          if (e.fields) {
-            for await (const [key2, val2] of Object.entries(
-              typeof e.fields === "string" ? e.fields.split(",") : e.fields
-            )) {
-              if (val.udfData) {
-                data[val2] = val["udfData"]["data"][val2];
-              } else {
-                data[val2] = null;
-              }
-            }
-          } else {
-            for await (const [key2, val2] of Object.entries(
-              table_obj.tableFields
-            )) {
-              if (val.udfData) {
-                data[val2.data.field_id] =
-                  val["udfData"]["data"][val2.data.field_id];
-              } else {
-                data[val2.data.field_id] = null;
-              }
-            }
-          }
-
-          rows.push({
-            id: val._id,
-            value: {
-              udfData: { data: data },
-              _id: val._id,
-              _rev: val._rev,
-            },
-          });
-        }
-
-        return {
-          code: 443,
-          data: { rows: rows, total_rows: rows.length },
-        };
-      };
-      const count_data = async function () {
-        var rows = [];
-        var keys_obj = {};
-        const table_index = find_item_by_key_root(
-          table_obj.tableIndexes,
-          "id",
-          e.indexId
-        );
-        if (e.indexId && table_index) {
-          var index_keys = table_index.data.keys;
-          var index_id = e.indexId;
-
-          for await (var val of body.docs) {
-            var data = {};
-            const _tableFieldsObj = find_item_by_key(
-              table_obj.tableFields,
-              "field_id",
-              e.field_id
-            );
-
-            for await (const [key2, val2] of Object.entries(
-              table_obj.tableFields
-            )) {
-              data[val2.data.field_id] =
-                val["udfData"]["data"][val2.data.field_id];
-            }
-
-            var key_arr = [];
-
-            for await (const [key_idx, key_name] of Object.entries(
-              index_keys
-            )) {
-              key_arr.push(data[key_name]);
-            }
-            keys_obj[key_arr]++;
-          }
-
-          for await (const [key_arr, key_count] of Object.entries(keys_obj)) {
-            rows.push({
-              key: [e.key, index_id, key_arr],
-              value: body.docs.length,
-            });
-          }
-        } else {
-          // no index
-          rows.push({ key: "", value: body.docs.length });
-        }
-        return {
-          code: 443,
-          data: { rows: rows, total_rows: rows.length },
-        };
-      };
-
-      const totals = async function () {
-        const median = (arr) => {
-          const mid = Math.floor(arr.length / 2),
-            nums = [...arr].sort((a, b) => a - b);
-          return arr.length % 2 !== 0
-            ? nums[mid]
-            : (nums[mid - 1] + nums[mid]) / 2;
-        };
-
-        var total_fields_info = JSON.parse(e.total_fields_info);
-        var totals_prop = {};
-        var totals_obj = {};
-        var totals_counts = {};
-        var totals_arr = {};
-        var totals_sums = {};
-        var totals_group_obj = {};
-
-        for await (const [key, val] of Object.entries(total_fields_info)) {
-          totals_counts[val.field_id] = 0;
-          totals_prop[val.field_id] = val;
-          totals_arr[val.field_id] = [];
-          totals_sums[val.field_id] = 0;
-          totals_group_obj[val.field_id] = {};
-        }
-
-        for await (var row_data of body.docs) {
-          for await (const [key, val] of Object.entries(
-            row_data.udfData.data
-          )) {
-            var field_id = key;
-            var value = val;
-            totals_counts[field_id]++;
-
-            switch (totals_prop[field_id].sum_type) {
-              case "sum":
-                if (typeof totals_obj[field_id] === "undefined") {
-                  totals_obj[field_id] = value;
-                } else {
-                  totals_obj[field_id] += value;
-                }
-                break;
-
-              case "average":
-                totals_sums[field_id] += value;
-                totals_obj[field_id] =
-                  totals_sums[field_id] / totals_counts[field_id];
-                break;
-
-              case "median":
-                if (!totals_arr[field_id].includes(value)) {
-                  totals_arr[field_id].push(value);
-                }
-                totals_obj[field_id] = median(totals_arr[field_id]);
-                break;
-              case "min":
-                if (
-                  typeof totals_obj[field_id] === "undefined" ||
-                  value < totals_obj[field_id]
-                ) {
-                  totals_obj[field_id] = value;
-                }
-                break;
-              case "max":
-                if (
-                  typeof totals_obj[field_id] === "undefined" ||
-                  value > totals_obj[field_id]
-                ) {
-                  totals_obj[field_id] = value;
-                }
-                break;
-              case "count":
-                if (typeof totals_obj[field_id] === "undefined") {
-                  totals_obj[field_id] = 1;
-                } else {
-                  totals_obj[field_id]++;
-                }
-                break;
-              case "distinct":
-                if (!totals_arr[field_id].includes(value)) {
-                  totals_arr[field_id].push(value);
-                }
-                totals_obj[field_id] = totals_arr[field_id].length;
-                break;
-
-              case "group":
-                if (!totals_obj[field_id]) {
-                  totals_obj[field_id] = {};
-                }
-
-                if (typeof totals_obj[field_id][value] === "undefined") {
-                  totals_obj[field_id][value] = 1; //value;
-                } else {
-                  totals_obj[field_id][value]++; //+= value;
-                }
-
-                break;
-              default:
-                totals_obj[field_id] = null;
-            }
-          }
-        }
-        return { code: 443, data: totals_obj };
-      };
-      if (e.count === "true" || e.count === true) {
-        return count_data();
-      }
-      if (e.total_fields_info) {
-        return totals();
-      }
-      return raw_data();
-    };
-
-    var limit = 99999;
-    var skip = 0;
-
-    if (e.limit) {
-      limit = parseInt(e.limit);
-    }
-
-    if (e.skip) {
-      skip = JSON.parse(e.skip);
-    }
-
-    var fields = [];
-    if (e.fields) {
-      for await (const [key, val] of Object.entries(
-        typeof e.fields === "string" ? e.fields.split(",") : e.fields
-      )) {
-        fields.push(val);
-      }
-    } else {
-      for await (const [key, val] of Object.entries(table_obj.tableFields)) {
-        fields.push(val.data.field_id);
-      }
-    }
-
-    var data = {};
-    var from = e.filter_from ? JSON.parse(e.filter_from) : {};
-    var to = e.filter_to ? JSON.parse(e.filter_to) : {};
-    var sort = [];
-    for await (const [key, val] of Object.entries(from)) {
-      var field_name = key;
-
-      sort.push(field_name);
-
-      if (val === to[key]) {
-        data[field_name] = val;
-      } else {
-        data[field_name] = { $gte: val };
-      }
-    }
-
-    for await (const [key, val] of Object.entries(to)) {
-      var field_name = key;
-
-      if (val !== from[key]) {
-        data[field_name]["$lte"] = val;
-      }
-    }
-
-    var selector = {};
-
-    if (from && !_.isEmpty(from)) {
-      selector = data;
-    }
-
-    var opt = {
-      selector: selector,
-      limit: limit,
-      skip: skip,
-      fields: fields,
-    };
-
-    if (sort.length) {
-      opt.sort = sort;
-    }
-
-    if (e.sort_fields && JSON.parse(e.sort_fields).length) {
-      opt.sort = JSON.parse(e.sort_fields);
-      if (opt.sort) {
-        for await (const [key, val] of Object.entries(opt.sort)) {
-          var field_name = val.colId;
-          opt.sort[key] = {
-            ["udfData.data." + field_name]: val.sort,
-          };
-        }
-      }
-    }
-
-    if (e.grid_filter_info) {
-      for await (const [key, val] of Object.entries(
-        JSON.parse(e.grid_filter_info)
-      )) {
-        var field_name = key;
-        var condition = "$and";
-        const make_selector = function (val) {
-          var value = "";
-          var operator = "";
-          var value_to = "";
-          var operator_to = "";
-
-          if (val.filterType === "date") {
-            var date = val.dateFrom.substr(0, 10);
-            switch (val.type) {
-              case "equals":
-                operator = "$regex";
-                value = `^${date}`;
-                break;
-
-              case "greaterThan":
-                operator = "$gt";
-                value = `${date}`;
-                break;
-
-              case "lessThan":
-                operator = "$lt";
-                value = `${date}`;
-                break;
-
-              case "blank":
-                operator = "$eq";
-                value = "";
-                break;
-
-              case "inRange":
-                operator = "$gte";
-                value = date;
-                operator_to = "$lte";
-                value_to = val.dateTo.substr(0, 10);
-                break;
-
-              case "notEqual":
-                operator = "$regex";
-                value = `^((?!${date}).)*$`;
-                break;
-
-              case "notBlank":
-                operator = "$ne";
-                value = "";
-                break;
-
-              default:
-                operator = "$regex";
-                value = `^${date}`;
-            }
-          }
-
-          if (val.filterType === "text") {
-            switch (val.type) {
-              case "contains":
-                operator = "$regex";
-                value = `${val.filter}`;
-                break;
-
-              case "notContains":
-                operator = "$regex";
-                value = `^((?!${val.filter}).)*$`;
-                break;
-
-              case "equals":
-                operator = "$eq";
-                value = `${val.filter}`;
-                break;
-
-              case "notEqual":
-                operator = "$ne";
-                value = `${val.filter}`;
-                break;
-
-              case "startsWith":
-                operator = "$regex";
-                value = `^${val.filter}`;
-                break;
-
-              case "endsWith":
-                operator = "$regex";
-                value = `${val.filter}$`;
-                break;
-
-              case "blank":
-                operator = "$eq";
-                value = "";
-                break;
-
-              case "notBlank":
-                operator = "$ne";
-                value = "";
-                break;
-
-              default:
-                value = "^" + val.filter;
-            }
-          }
-
-          if (val.filterType === "number") {
-            switch (val.type) {
-              case "equals":
-                operator = "$eq";
-                value = val.filter;
-                break;
-
-              case "notEqual":
-                operator = "$ne";
-                value = val.filter;
-                break;
-
-              case "lessThanOrEqual":
-                operator = "$lte";
-                value = val.filter;
-                break;
-
-              case "greaterThanOrEqual":
-                operator = "$gte";
-                value = val.filter;
-                break;
-
-              case "lessThan":
-                operator = "$lt";
-                value = val.filter;
-                break;
-
-              case "greaterThan":
-                operator = "$gt";
-                value = val.filter;
-                break;
-
-              case "blank":
-                operator = "$eq";
-                value = 0;
-                break;
-
-              case "notBlank":
-                operator = "$ne";
-                value = 0;
-                break;
-
-              case "inRange":
-                operator = "$gte";
-                value = val.filter;
-                operator_to = "$lte";
-                value_to = val.filterTo;
-                break;
-
-              default:
-                operator = "$eq";
-                value = val.filter;
-            }
-          }
-          if (!opt.selector[field_name]) {
-            opt.selector[field_name] = {};
-          }
-          if (!opt.selector[field_name][condition]) {
-            opt.selector[field_name][condition] = [];
-          }
-          opt.selector[field_name][condition].push({
-            [operator]: value,
-          });
-
-          if (operator_to) {
-            opt.selector[field_name][condition].push({
-              [operator_to]: value_to,
-            });
-          }
-        };
-
-        if (!val.condition1) {
-          make_selector(val);
-        } else {
-          condition = "$" + val.operator.toLowerCase();
-          make_selector(val.condition1);
-          make_selector(val.condition2);
-        }
-      }
-    }
-
-    if (e.total_fields_info) {
-      fields = [];
-      for await (const [key, val] of Object.entries(
-        JSON.parse(e.total_fields_info)
-      )) {
-        var field_name = val.field_id;
-
-        fields.push(field_name);
-      }
-      opt.fields = fields;
-    }
-    // fix names
-
-    for await (const [key, val] of Object.entries(opt.fields)) {
-      opt.fields[key] = "udfData.data." + val;
-    }
-    if (!e.sort_fields || !JSON.parse(e.sort_fields).length) {
-      // added 2021 09 10
-      if (opt.sort) {
-        for await (const [key, val] of Object.entries(opt.sort)) {
-          opt.sort[key] = {
-            ["udfData.data." + val]: e.sortOrder === "des" ? "desc" : "asc",
-          };
-        }
-      }
-    }
-
-    var selector_new = {};
-
-    for await (const [key, val] of Object.entries(opt.selector)) {
-      selector_new["udfData.data." + key] = val;
-    }
-
-    if (e.viewDbQuery) {
-      for await (const [key, val] of Object.entries(table_obj.tableFields)) {
-        if (e.viewDbQuery.includes(val.id)) {
-          const replacer = new RegExp(val.id, "g");
-          e.viewDbQuery = e.viewDbQuery.replace(
-            replacer,
-            "udfData.data." + val.data.field_id
-          );
-        }
-      }
-
-      let viewDbQuery = JSON.parse(e.viewDbQuery.replace(/\\/g, ""));
-
-      for await (const [key, val] of Object.entries(viewDbQuery)) {
-        selector_new[key] = val;
-      }
-    }
-
-    opt.selector = selector_new;
-    opt.selector["udfData.udffileid"] = e.fileId;
-    opt.selector.stat = e.archived ? 4 : 3;
-
-    opt.fields.push("_id");
-    opt.fields.push("_rev");
-
-    // xuda
-    var cache_string = JSON.stringify(opt);
-
-    if (
-      // __.CACHE_QUERY_REQ[app_id_reference] &&
-      // __.CACHE_QUERY_REQ[app_id_reference][e.table_id] &&
-      __.CACHE_QUERY_REQ?.[app_id_reference]?.[e.table_id]?.[cache_string]
-    ) {
-      return await done(
-        __.CACHE_QUERY_REQ[app_id_reference][e.table_id][cache_string].doc
-      );
-    }
-    try {
-      try {
-        const doc = await db.find(opt);
-        if (!__.CACHE_QUERY_REQ[app_id_reference]) {
-          __.CACHE_QUERY_REQ[app_id_reference] = {};
-        }
-
-        if (!__.CACHE_QUERY_REQ[app_id_reference][e.table_id]) {
-          __.CACHE_QUERY_REQ[app_id_reference][e.table_id] = {};
-        }
-
-        __.CACHE_QUERY_REQ[app_id_reference][e.table_id][cache_string] = {
-          doc: doc,
-          ts: Date.now(),
-        };
-
-        if (doc?.warning?.includes("No matching index found")) {
-          const index_name = `index_${e.table_id}_${new Date()
-            .valueOf()
-            .toString()}`;
-          var index = [];
-
-          for await (const [key, val] of Object.entries(opt.selector)) {
-            index.push(key);
-          }
-          mango_index_obj = {
-            index: {
-              fields: index,
-            },
-            name: index_name,
-            ddoc: `mango_index_table_${e.table_id}`,
-          };
-          db.createIndex(mango_index_obj).then((result) => {
-            console.log(result);
-          });
-        }
-        return await done(doc);
-      } catch (err) {
-        if (err.error === "no_usable_index") {
-          const index_name = `index_${e.table_id}_${new Date()
-            .valueOf()
-            .toString()}`;
-
-          mango_index_obj = {
-            index: {
-              fields: opt.sort,
-            },
-            name: index_name,
-            ddoc: `mango_index_table_${e.table_id}`,
-          };
-
-          try {
-            const result = await db.createIndex(mango_index_obj);
-            // try {
-            const doc = await db.find(opt);
-            return await done(doc);
-            // } catch (err) {
-            //   return { code: -443, data: err.message };
-            // }
-          } catch (error) {
-            return { code: -400, data: error };
-          }
-        } else {
-          return { code: -444, data: err.message };
-        }
-      }
-    } catch (err) {
-      return { code: -445, data: err.error };
-    }
-  };
-
-  const runtime_get_query_data = async function () {
-    var limit = 99999;
-    var skip = 0;
-
-    if (e.limit) {
-      limit = e.limitP;
-    }
-
-    if (e.skipP) {
-      skip = e.skipP;
-    }
-
-    var desc = e.desc === "true" ? true : false;
-
-    var opt;
-    if (key) {
-      opt = {
-        key: key,
-        include_docs: !e.ids && view !== "db_index_reduce",
-        limit: limit,
-        skip: skip,
-      };
-    } else {
-      if (e.reduce == "true") {
-        opt = {
-          startkey: e.startkey ? JSON.parse(e.startkey) : "",
-          endkey: e.endkey ? JSON.parse(e.endkey) : "",
-          include_docs: false,
-          reduce: true,
-          group_level: 3,
-
-          descending: desc,
-        };
-      } else {
-        opt = {
-          startkey: e.startkey ? JSON.parse(e.startkey) : "",
-          endkey: e.endkey ? JSON.parse(e.endkey) : "",
-          include_docs: !e.ids,
-          limit: limit,
-          skip: skip,
-          descending: desc,
-        };
-      }
-    }
-
-    try {
-      const body = db.view(`xuda`, view, opt);
-      if (e.reduce) {
-        return { code: 440, data: body };
-      }
-      var rows = [];
-
-      for await (var val of body.rows) {
-        if (e.ids) {
-          rows.push({ id: val.id, value: val.value._id });
-          return true;
-        }
-        rows.push({
-          id: val.id,
-          value: { udfData: val.doc.udfData, _id: val.id },
-        });
-      }
-      return {
-        code: 440,
-        data: { rows: rows, total_rows: rows.length },
-      };
-    } catch (error) {
-      return { code: -442, data: error };
-    }
-  };
-
-  if (e.reduce && JSON.parse(e.reduce)) {
-    view = "db_index_reduce";
-    return await runtime_get_query_data();
-  }
-  if (e.view === "db_index") {
-    key = e.key;
-    view = e.view;
-    return await runtime_get_query_data();
-  }
-  return await runtime_get_mango_data();
-};
-export const Update = async (_, e, db, app_id_reference, table_obj) => {
-  try {
-    const doc = await db.get(e.row_id, {});
-    let data = doc.udfData.data;
-    var error;
-
-    const _tableFieldsObj = find_item_by_key(
-      table_obj.tableFields,
-      "field_id",
-      e.field_id
-    );
-    if (!_tableFieldsObj || _.isEmpty(_tableFieldsObj)) {
-      return {
-        code: -552,
-        data: "Error:" + e.field_id + " - field not found",
-      };
-    }
-
-    data[e.field_id] = await get_cast_val(
-      "runtime_update_data",
-      e.field_id,
-      _tableFieldsObj.props.fieldType,
-      e.field_value
-    );
-    if (error) {
-      return {
-        code: -554,
-        data: error,
-      };
-    }
-
-    doc.ts = Date.now();
-    const index_ret = await get_index_json(doc, table_obj);
-    if (index_ret.code < 0) {
-      return index_ret;
-    }
-    doc.udfIndex = index_ret.data;
-    const ret = await check_unique(doc, table_obj);
-    if (ret.code < 0) {
-      return ret;
-    }
-    try {
-      const body = await db.insert(doc);
-      return { code: 460, data: body };
-    } catch (error) {
-      return { code: -460, data: error };
-    }
-  } catch (error) {
-    return { code: -550, data: error };
-  }
-};
-export const Delete = async (_, e, db, app_id_reference, table_obj) => {
-  const data = await db.fetch({ keys: e.ids });
-  for await (var val of data.rows) {
-    var doc = val.doc;
-
-    if (doc && doc._id) {
-      if (e.permanent) {
-        docs_to_delete.push({
-          _id: doc._id,
-          _rev: doc._rev,
-          _deleted: true,
-        });
-      } else {
-        doc.stat = 4;
-        doc.ts = new Date().valueOf();
-        docs_to_delete.push(doc);
-      }
-    }
-  }
-  try {
-    await db.bulk({ docs: docs_to_delete });
-    return { code: 110, data: docs_to_delete };
-  } catch (error) {
-    return { code: -110, data: error };
-  }
-};
-
-export const Restore = async (_, e, db, app_id_reference, table_obj) => {
-  var docs_to_restore = [];
-  const data = await db.fetch({ keys: e.ids });
-
-  for await (var val of data.rows) {
-    var doc = val.doc;
-
-    if (doc && doc._id) {
-      doc.stat = 3;
-      doc.ts = new Date().valueOf();
-      docs_to_restore.push(doc);
-    }
-  }
-
-  try {
-    await db.bulk({ docs: docs_to_restore });
-    return { code: 110, data: docs_to_restore };
-  } catch (error) {
-    return { code: -110, data: error };
-  }
-};
-
-// export const test_connection = async (node_modules_path, setup_doc) => {
-//   try {
-//     if (!setup_doc.db_connection_string) throw "db_connection_string missing";
-//     const nano = require(node_modules_path + "/nano")(
-//       setup_doc.db_connection_string
-//     );
-//     // const nano = await import(node_modules_path + "/nano")(
-//     //   setup_doc.db_connection_string
-//     // );
-//     if (!nano) {
-//       return { code: -450, data: "connection error" };
-//     }
-//     await nano.get("_design");
-//     return { code: 450, data: nano };
-//   } catch (err) {
-//     return { code: -450, data: err };
-//   }
-// };