@xuda.io/xuda-dbs-plugin-xuda 1.0.46 → 1.0.48

package/server.js

@@ -1,6 +1,6 @@
 const _ = require("lodash");
 
-const check_unique = async function (e, docP, table_obj) {
+const check_unique = async function (e, docP, table_obj, db, app_id_reference) {
   var len = docP.udfIndex.length;
   if (!len) {
     return { code: -11, data: "table must have primary index" };
@@ -70,9 +70,9 @@ const check_unique = async function (e, docP, table_obj) {
       keyValue.join(",") +
       "]]";
     try {
-      // const json = await _this.runtime_xuda_driver("runtime_get_index", e);
       e.view = "db_index";
-      const json = await exports.read(params, setup_doc, resolve, reject);
+      const ret = await query_db(e, db, app_id_reference, table_obj);
+      const json = ret.data;
 
       // var data;
 
@@ -186,6 +186,690 @@ const get_cast_val = async function (source, attributeP, typeP, valP) {
     }
   );
 };
+const query_db = async function (e, db, app_id_reference, 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: 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 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: 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 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: 1, 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.table_id;
+    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]?.[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 { code: -1, data: error };
+          }
+        } else {
+          return { code: -1, data: err.message };
+        }
+      }
+    } catch (err) {
+      return { code: -1, 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: 1, 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: 1, data: { rows: rows, total_rows: rows.length } };
+    } catch (error) {
+      return { code: -1, 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();
+};
 
 exports.create = async (params, setup_doc, resolve, reject) => {
   const e = params.e;
@@ -215,7 +899,7 @@ exports.create = async (params, setup_doc, resolve, reject) => {
         if (index_ret < 0) throw index_ret.data;
         doc.udfIndex = index_ret.data;
 
-        const ret = await check_unique(e, doc, table_obj);
+        const ret = await check_unique(e, doc, table_obj, db, app_id_reference);
         if (ret.code < 0) {
           throw ret;
         }
@@ -251,7 +935,7 @@ exports.create = async (params, setup_doc, resolve, reject) => {
       return index_ret;
     }
     doc.udfIndex = index_ret.data;
-    const ret = await check_unique(e, doc, table_obj);
+    const ret = await check_unique(e, doc, table_obj, db, app_id_reference);
     if (ret.code < 0) {
       return ret;
     }
@@ -273,6 +957,13 @@ exports.read = async (params, setup_doc, resolve, reject) => {
   const app_id_reference = params.app_id_reference;
   const table_obj = params.table_obj;
 
+  const ret = await query_db(e, db, app_id_reference, table_obj);
+  if (ret.code < 0) {
+    return reject(ret.data);
+  }
+
+  return resolve(ret.data);
+
   var key;
 
   const runtime_get_mango_data = async function () {
@@ -965,33 +1656,59 @@ 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";
+    }
+    // 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) {
       return index_ret;
     }
     doc.udfIndex = index_ret.data;
-    const ret = await check_unique(e, doc, table_obj);
+    const ret = await check_unique(e, doc, table_obj, db, app_id_reference);
     if (ret.code < 0) {
       return ret;
     }
@@ -1011,6 +1728,8 @@ exports.delete = async (params, setup_doc, resolve, reject) => {
   const app_id_reference = params.app_id_reference;
   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;
 
@@ -1073,6 +1792,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);
   }
 };