@xuda.io/xuda-dbs-plugin-xuda 1.0.1

package/index.mjs

@@ -0,0 +1,1025 @@
+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);
+
+      // 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 };
+  }
+};
+
+export const Create = async (e, db, 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 (e, db, 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);
+      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
+
+      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);
+    const app_id_reference = await _this.get_app_id(e.app_id);
+    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, 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, 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, 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 };
+  }
+};

package/package.json

@@ -0,0 +1,17 @@
+{
+  "name": "@xuda.io/xuda-dbs-plugin-xuda",
+  "version": "1.0.1",
+  "description": "Xuda Database Socket for Xuda's proprietary structure powered by CouchDB",
+  "scripts": {
+    "pub": "npm version patch --force && npm publish --access public"
+  },
+  "keywords": [
+    "dbs",
+    "socket",
+    "xuda",
+    "plugin"
+  ],
+  "author": "xuda.io",
+  "license": "Proprietary software licenses",
+  "svg_icon": "<svg xmlns=\"http://www.w3.org/2000/svg\" xmlns:xlink=\"http://www.w3.org/1999/xlink\" width=\"24px\" height=\"24px\" viewBox=\"0 0 256 256\" version=\"1.1\" preserveAspectRatio=\"xMidYMid\"> <g> <path d=\"M128.151659,0.00118559798 C148.92891,0.00118559798 168.492891,4.85546114 186.843602,14.2583047 L186.843602,14.2583047 L189.270142,15.4715749 L187.146919,17.1398213 C181.990521,21.2346081 177.895735,26.5426649 175.317536,32.6090156 L175.317536,32.6090156 L174.559242,34.2772621 L173.042654,33.5189682 C158.938389,26.8459825 143.924171,23.3578308 128.303318,23.3578308 C70.521327,23.3578308 23.6587678,70.3720488 23.6587678,128.002381 C23.6587678,185.632712 70.3696682,232.64693 128.151659,232.64693 C185.933649,232.64693 232.796209,185.632712 232.796209,128.002381 C232.796209,114.201433 230.218009,100.703802 224.758294,87.9644659 L224.758294,87.9644659 L224,86.2962194 L225.668246,85.5379256 C231.886256,83.2630441 237.345972,79.4715749 241.744076,74.6184943 L241.744076,74.6184943 L243.412322,72.4952716 L244.473934,74.9218119 C252.208531,91.7559351 256,109.65167 256,127.699063 C256,198.22039 198.521327,255.699063 128,255.699063 C57.478673,255.699063 0,198.22039 0,127.699063 C0,57.177736 57.478673,-0.300936964 128.151659,0.00118559798 Z M128.151659,69.7654137 C160.151659,69.7654137 186.388626,95.8507218 186.540284,128.154039 C186.540284,160.457357 160.454976,186.542665 128.151659,186.542665 C95.8483412,186.542665 69.7630332,160.457357 69.7630332,128.154039 C69.7630332,95.8507218 96,69.7654137 128.151659,69.7654137 Z M211.71564,21.5379256 C226.457193,21.5379256 238.407583,33.4883156 238.407583,48.2298687 C238.407583,62.9714219 226.457193,74.9218119 211.71564,74.9218119 C196.974087,74.9218119 185.023697,62.9714219 185.023697,48.2298687 C185.023697,33.4883156 196.974087,21.5379256 211.71564,21.5379256 Z\" fill=\"#3880FF\"/> </g> </svg>"
+}

package/setup.mjs

@@ -0,0 +1,39 @@
+export function tabs(doc) {
+  return {
+    accounts: {
+      svg_icon:
+        '<svg xmlns="http://www.w3.org/2000/svg" class="icon icon-tabler icon-tabler-palette" width="44" height="44" viewBox="0 0 24 24" stroke-width="1.5" stroke="#2c3e50" fill="none" stroke-linecap="round" stroke-linejoin="round"> <path stroke="none" d="M0 0h24v24H0z" fill="none"/> <path d="M12 21a9 9 0 1 1 0 -18a9 8 0 0 1 9 8a4.5 4 0 0 1 -4.5 4h-2.5a2 2 0 0 0 -1 3.75a1.3 1.3 0 0 1 -1 2.25" /> <circle cx="7.5" cy="10.5" r=".5" fill="currentColor" /> <circle cx="12" cy="7.5" r=".5" fill="currentColor" /> <circle cx="16.5" cy="10.5" r=".5" fill="currentColor" /> </svg>',
+      text: "Accounts",
+      type: "multi",
+
+      fields: {
+        db_name: {
+          type: "text",
+          placeholder: "My Db",
+          mandatory: true,
+          label: "Name",
+          size: 12,
+          value: `Main Db`,
+        },
+        db_connection_string: {
+          type: "text",
+          placeholder: "https://john:12345678@db.xuda.io:6984/employees",
+          mandatory: true,
+          label: "Db Connection String",
+          size: 12,
+          value: `https://${doc.app_db_admin_username}:${doc.app_db_admin_password}@db.xuda.io/${doc.app_db_name}`,
+        },
+      },
+    },
+  };
+}
+
+export function public_filter(doc) {
+  var ret = {};
+
+  for (const [key, val] of Object.entries(doc.accounts)) {
+    ret[key] = {};
+  }
+
+  return ret;
+}