@xuda.io/xuda-dbs-plugin-xuda 1.0.23 → 1.0.25

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@xuda.io/xuda-dbs-plugin-xuda",
-  "version": "1.0.23",
+  "version": "1.0.25",
   "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

@@ -0,0 +1,1057 @@
+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;
+  });
+};
+
+exports.create = 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;
+
+  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 resolve(body);
+      } catch (error) {
+        return reject(error);
+      }
+    } catch (msg) {
+      return reject(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 resolve(body);
+    } catch (error) {
+      return reject(error);
+    }
+  };
+  if (Array.isArray(e.table_data)) {
+    return await batch();
+  }
+  return await single();
+};
+exports.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 resolve({ 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 resolve({ 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 resolve(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);
+
+            const doc = await db.find(opt);
+            return await done(doc);
+          } catch (error) {
+            return reject(error);
+          }
+        } else {
+          return reject(err.message);
+        }
+      }
+    } catch (err) {
+      return reject(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 resolve(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 resolve({ rows: rows, total_rows: rows.length });
+    } catch (error) {
+      return reject(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();
+};
+exports.update = 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;
+  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 reject("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 reject(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 resolve(body);
+    } catch (error) {
+      return reject(error);
+    }
+  } catch (error) {
+    return reject(error);
+  }
+};
+exports.delete = 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;
+  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 });
+    resolve(docs_to_delete);
+  } catch (error) {
+    return { code: -110, data: error };
+  }
+};
+
+exports.restore = 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 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 });
+    resolve(docs_to_restore);
+  } catch (error) {
+    return reject(error);
+  }
+};
+
+exports.test_connection = async (params, setup_doc) => {
+  try {
+    debugger;
+    if (!setup_doc.db_connection_string) throw "db_connection_string missing";
+    const nano = require("nano")(setup_doc.db_connection_string);
+
+    if (!nano) {
+      return reject("connection error");
+    }
+    await nano.get("_design/xuda");
+    resolve(nano);
+  } catch (err) {
+    return reject(err);
+  }
+};