@xuda.io/xuda-dbs-plugin-xuda 1.0.94 → 1.0.96

package/package.json

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

package/studio.mjs

@@ -0,0 +1,1215 @@
+const check_unique = async function (e, docP, table_obj, db) {
+  var len = docP.udfIndex.length;
+  if (!len) {
+    return { code: -11, data: "table must have primary index" };
+  }
+  var found_unique = undefined;
+  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[Number(keySegment)]
+      );
+      keyValue.push(_val);
+    }
+
+    var key =
+      '["' +
+      val.fileId +
+      '","' +
+      val.indexId +
+      '",[' +
+      keyValue.join(",") +
+      "]]";
+    try {
+      e.view = "db_index";
+      const ret = await query_db(e, db, table_obj);
+      const json = ret.data;
+
+      // 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;
+  });
+};
+
+const find_item_by_key = function (arr, key, val) {
+  return _.find(arr, function (e) {
+    return e.data[key] === val;
+  });
+};
+
+const get_cast_val = async function (source, attributeP, typeP, valP) {
+  return xu_cast(
+    typeP,
+    valP,
+    function (res) {
+      var msg = `error converting  ${attributeP} from ${valP} to ${typeP}`;
+      console.error(source, msg);
+    },
+    function (res) {
+      var msg = `type mismatch auto conversion made to ${attributeP} from value ${valP} to ${typeP}`;
+      console.warn(source, msg);
+    }
+  );
+};
+const query_db = async function (e, db, table_obj) {
+  var key = undefined;
+
+  const runtime_get_mango_data = async function () {
+    const done = async function (body) {
+      const raw_data = async function () {
+        var rows = [];
+
+        for (var val of body.docs) {
+          var data = {};
+          if (e.fields) {
+            for (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 (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: data,
+          });
+        }
+
+        return { code: 1, 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 (var val of body.docs) {
+            var data = {};
+            const _tableFieldsObj = find_item_by_key(
+              table_obj.tableFields,
+              "field_id",
+              e.field_id
+            );
+
+            for (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 (const [key_idx, key_name] of Object.entries(index_keys)) {
+              key_arr.push(data[key_name]);
+            }
+            keys_obj[key_arr]++;
+          }
+
+          for (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: 1, 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 (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 (var row_data of body.docs) {
+          for (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: 1, data: totals_obj };
+      };
+      if (e.count) {
+        return count_data();
+      }
+      if (e.total_fields_info) {
+        return totals();
+      }
+      return raw_data();
+    };
+
+    var limit = 99999;
+    var skip = 0;
+
+    if (e.limit) {
+      limit = Number(e.limit);
+    }
+
+    if (e.skip) {
+      skip = JSON.parse(e.skip);
+    }
+
+    var fields = [];
+    if (e.fields) {
+      for (const [key, val] of Object.entries(
+        typeof e.fields === "string" ? e.fields.split(",") : e.fields
+      )) {
+        fields.push(val);
+      }
+    } else {
+      for (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 (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 (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,
+      limit: limit,
+      skip: skip,
+      fields: fields,
+    };
+
+    if (sort.length) {
+      opt.sort = sort;
+    }
+
+    if (e?.sort_fields?.length) {
+      opt.sort = e.sort_fields;
+      if (opt.sort) {
+        for (const [key, val] of Object.entries(opt.sort)) {
+          var field_name = val.colId;
+          opt.sort[key] = {
+            ["udfData.data." + field_name]: val.sort,
+          };
+        }
+      }
+    }
+    // if (e.sort_fields && JSON.parse(e.sort_fields).length) {
+    //   opt.sort = JSON.parse(e.sort_fields);
+    //   if (opt.sort) {
+    //     for (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 (const [key, val] of Object.entries(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 === "string" || 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 (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 (const [key, val] of Object.entries(opt.fields)) {
+      opt.fields[key] = "udfData.data." + val;
+    }
+    if (!e?.sort_fields?.length) {
+      // added 2021 09 10
+      if (opt.sort) {
+        for (const [key, val] of Object.entries(opt.sort)) {
+          opt.sort[key] = {
+            ["udfData.data." + val]: e.sortOrder === "des" ? "desc" : "asc",
+          };
+        }
+      }
+    }
+    // if (!e.sort_fields || !JSON.parse(e.sort_fields).length) {
+    //   // added 2021 09 10
+    //   if (opt.sort) {
+    //     for (const [key, val] of Object.entries(opt.sort)) {
+    //       opt.sort[key] = {
+    //         ["udfData.data." + val]: e.sortOrder === "des" ? "desc" : "asc",
+    //       };
+    //     }
+    //   }
+    // }
+
+    var selector_new = {};
+
+    for (const [key, val] of Object.entries(opt.selector)) {
+      selector_new["udfData.data." + key] = val;
+    }
+
+    if (e.viewDbQuery) {
+      for (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 (const [key, val] of Object.entries(viewDbQuery)) {
+        selector_new[key] = val;
+      }
+    }
+
+    opt.selector = selector_new;
+    opt.selector["udfData.udffileid"] = e.table_id;
+    opt.selector.stat = e.archived ? 4 : 3;
+
+    opt.fields.push("_id");
+    opt.fields.push("_rev");
+
+    if (e.selector) {
+      opt.selector = { ...e.selector, ...opt.selector };
+    }
+
+    // xuda
+
+    try {
+      try {
+        // console.log("opt", opt);
+        const doc = await db.find(opt);
+
+        if (doc?.warning?.includes("No matching index found")) {
+          const index_name = `index_${e.table_id}_${new Date()
+            .valueOf()
+            .toString()}`;
+          var index = [];
+
+          for (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 (err) {
+            return { code: -1, data: err.message };
+          }
+        } else {
+          return { code: -1, data: err.message };
+        }
+      }
+    } catch (err) {
+      return { code: -1, data: err.message };
+    }
+  };
+
+  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 opt = undefined;
+    if (key) {
+      opt = {
+        key: key,
+        include_docs: !e.ids && view !== "db_index_reduce",
+        limit: limit,
+        skip: skip,
+      };
+    } else {
+      if (e.reduce) {
+        opt = {
+          startkey: e.startkey ? JSON.parse(e.startkey) : "",
+          endkey: e.endkey ? JSON.parse(e.endkey) : "",
+          include_docs: false,
+          reduce: true,
+          group_level: 3,
+
+          descending: e.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: e.desc,
+        };
+      }
+    }
+
+    try {
+      const body = await db.query(view, opt);
+      if (e.reduce) {
+        let rows = [];
+
+        const table_index = find_item_by_key_root(
+          table_obj.tableIndexes,
+          "id",
+          e.indexId
+        );
+
+        for await (var val of body.rows) {
+          const arr = val.key[2];
+
+          var obj = {};
+          for await (const [arr_key, arr_val] of Object.entries(arr)) {
+            let field_id = table_index.data.keys[Number(arr_key)];
+
+            const _tableFieldsObj = find_item_by_key(
+              table_obj.tableFields,
+              "field_id",
+              field_id
+            );
+
+            let field_value = await get_cast_val(
+              "dbs_update",
+              e.field_id,
+              _tableFieldsObj.props.fieldType,
+              arr_val
+            );
+
+            obj[field_id] = field_value;
+          }
+          obj["REDUCE_VALUE"] = val.value;
+
+          rows.push({ id: crypto.randomUUID(), value: obj });
+        }
+        return { code: 1, data: { rows } };
+      }
+
+      var rows = [];
+
+      for await (var val of body.rows) {
+        if (e.ids) {
+          rows.push({ id: val.id, value: val.value._id });
+          continue;
+        }
+        rows.push({
+          id: val.id,
+          value: val.doc.udfData,
+          // value: { udfData: val.doc.udfData, _id: val.id },
+        });
+      }
+
+      // const reduce_rows = () => {
+      // const reduce_obj = body.docs.reduce(
+      //   (params, data) => {
+      //     const fx = (val, idx) => {
+      //       const group_by_field = data[params.sort[idx]];
+
+      //       if (params.sort[idx + 1]) {
+      //         val[group_by_field] = val[group_by_field] ?? {};
+      //         val[group_by_field][data[params.sort[idx + 1]]] = 0;
+      //         idx++;
+      //         fx(val[group_by_field], idx);
+      //         return;
+      //       }
+
+      //       val[group_by_field] = val[group_by_field] ?? 0;
+      //       val[group_by_field] += 1;
+      //     };
+      //     fx(params.group, 0);
+
+      //     return params;
+      //   },
+      //   { sort: opt.sort, group: {} }
+      // );}
+
+      return { code: 1, data: { rows: rows, total_rows: rows.length } };
+    } catch (err) {
+      return { code: -1, data: err.message };
+    }
+  };
+
+  const count_tables = async function () {
+    var opt = {
+      reduce: true,
+      group_level: 1,
+    };
+
+    if (e.table_id) {
+      opt.key = e.table_id;
+    }
+
+    const body = await db.query("db_table_counts", opt);
+
+    return { code: 1, data: body };
+  };
+
+  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();
+  }
+
+  if (e.count && !e.filter_from) {
+    // count tables
+    return await count_tables();
+  }
+
+  return await runtime_get_mango_data();
+};
+
+export const create = async (params, resolve, reject) => {
+  const e = params.e;
+  const db = params.db;
+
+  const table_obj = params.table_obj;
+
+  const create_data_obj = async function (table_data) {
+    var doc = {};
+    for await (const val of table_obj.tableFields) {
+      doc[val.data.field_id] = await get_cast_val(
+        "dbs_create",
+        val.data.field_id,
+        val.props.fieldType,
+        table_data[val.data.field_id]
+      );
+    }
+
+    return doc;
+  };
+
+  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: await create_data_obj(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(e, doc, table_obj, db);
+        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: await create_data_obj(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(e, doc, table_obj, db);
+    if (ret.code < 0) {
+      return reject(ret.data);
+    }
+    try {
+      const body = await db.put(doc);
+      return resolve(body);
+    } catch (error) {
+      return reject(error);
+    }
+  };
+  if (Array.isArray(e.table_data)) {
+    return await batch();
+  }
+  return await single();
+};
+export const read = async (params, resolve, reject) => {
+  const e = params.e;
+  const db = params.db;
+
+  const table_obj = params.table_obj;
+
+  const ret = await query_db(e, db, table_obj);
+  if (ret.code < 0) {
+    return reject(ret.data);
+  }
+
+  return resolve(ret.data);
+};
+export const update = async (params, resolve, reject) => {
+  const e = params.e;
+  const db = params.db;
+
+  const table_obj = params.table_obj;
+  try {
+    if (e.row_id === "newRecord") {
+      return this.create(params, resolve, reject);
+    }
+    var doc = await db.get(e.row_id, {});
+    // let data = doc.udfData.data;
+    var error = undefined;
+    if (!e.field_id && !e.table_data) {
+      error = "Invalid field_id or table_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");
+      }
+
+      doc.udfData.data[e.field_id] = await get_cast_val(
+        "dbs_update",
+        e.field_id,
+        _tableFieldsObj.props.fieldType,
+        e.field_value
+      );
+    }
+
+    // object value save
+    if (e.table_data) {
+      // data = {};
+      for await (const [key, val] of Object.entries(e.table_data)) {
+        let _tableFieldsObj = find_item_by_key(
+          table_obj.tableFields,
+          "field_id",
+          key
+        );
+        if (!_tableFieldsObj || _.isEmpty(_tableFieldsObj)) {
+          reject("Error: " + key + " - field not found");
+          break;
+        }
+
+        doc.udfData.data[key] = await get_cast_val(
+          "dbs_update",
+          key,
+          _tableFieldsObj.props.fieldType,
+          val
+        );
+      }
+    }
+
+    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(e, doc, table_obj, db);
+    if (ret.code < 0) {
+      return ret;
+    }
+    try {
+      const body = await db.put(doc);
+      return resolve(body);
+    } catch (error) {
+      return reject(error);
+    }
+  } catch (error) {
+    return reject(error);
+  }
+};
+export const del = async (params, resolve, reject) => {
+  const e = params.e;
+  const db = params.db;
+
+  const table_obj = params.table_obj;
+  const data = await db.fetch({ keys: e.ids });
+  var docs_to_delete = [];
+
+  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 };
+  }
+};
+
+export const restore = async (params, resolve, reject) => {
+  const e = params.e;
+  const db = params.db;
+  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);
+  }
+};
+
+export const _design = async (params, resolve, reject) => {
+  const db = params.db;
+
+  const ddoc = {
+    _id: "_design/xuda",
+    views: {
+      db_index_reduce: {
+        map: 'function(doc) {\r\n    if (doc.docType=="database" && doc.stat===3) {\r\n        if (doc.udfIndex) {\r\n            for (var i = 0; i < doc.udfIndex.length; i++)\r\n            {\r\n                var val = doc.udfIndex[i]; \r\n                emit([val.fileId, val.indexId, val.keyValue],1);\r\n            }\r\n        }\r\n    }\r\n \r\n}',
+        reduce: "function(keys, values) {\n  return sum(values);\n}",
+      },
+      db_index: {
+        map: 'function(doc) {\r\n    if (doc.docType=="database" && doc.stat===3) {\r\n        if (doc.udfIndex) {\r\n            for (var i = 0; i < doc.udfIndex.length; i++)\r\n            {\r\n                var val = doc.udfIndex[i]; \r\n                emit([val.fileId, val.indexId, val.keyValue],{_id: doc._id});\r\n            }\r\n        }\r\n    }\r\n \r\n}',
+      },
+
+      db_table_counts: {
+        map: 'function(doc) {\r\n\r\nif (doc.docType=="database" && doc.stat===3) {\r\n        if(doc.udfData && doc.udfData.udffileid) \r\n            emit(doc.udfData.udffileid, 1); \r\n    }\r\n}',
+        reduce: "function(keys, values) {\n  return sum(values);\n}",
+      },
+    },
+  };
+
+  try {
+    const ret = await db.put(ddoc, { timeout: 99999999999 });
+    resolve(ret);
+  } catch (error) {
+    return reject(error);
+  }
+};