spice-couchbase 2.0.13 → 2.0.16

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "spice-couchbase",
-  "version": "2.0.13",
+  "version": "2.0.16",
   "description": "",
   "main": "build/index.js",
   "scripts": {
@@ -9,8 +9,10 @@
   "author": "Chad Fraser <chad@sonover.com> (http://sonover.com)",
   "license": "ISC",
   "dependencies": {
-    "couchbase": "^3.0.6",
-    "lodash": "^4.17.15"
+    "axios": "^0.26.1",
+    "couchbase": "^4.0.0",
+    "lodash": "^4.17.15",
+    "qs": "^6.10.3"
   },
   "devDependencies": {
     "@babel/cli": "^7.7.7",

package/src/index.js

@@ -1,136 +1,285 @@
 "use strict";
 
-let _ = require('lodash');
-let couchbase = require('couchbase');
+let _ = require("lodash");
+let couchbase = require("couchbase");
+const { default: axios } = require("axios");
+var qs = require("qs");
+
+if (!Promise.allSettled) {
+  Promise.allSettled = (promises) =>
+    Promise.all(
+      promises.map((promise, i) =>
+        promise
+          .then((value) => ({
+            status: "fulfilled",
+            value,
+          }))
+          .catch((reason) => ({
+            status: "rejected",
+            reason,
+          }))
+      )
+    );
+}
 module.exports = class Database {
-  constructor(connection, full_text_index) {
+  constructor(
+    connection,
+    {
+      full_text_index,
+      collection,
+      scope,
+      query_scope = "cluster",
+      auto_create_collection,
+    } = {}
+  ) {
     if (connection) {
       this.connection_name = connection;
       this.connection = spice.database.connections[connection];
-      this.cluster = spice.database.clusters[connection]
+      this.query_scope = query_scope;
+      this.cluster = spice.database.clusters[connection];
       this.bucket = this.connection._scope._bucket._name;
-      this.full_text_index = spice.config.database.connections[connection].full_text_index || full_text_index;
-      this.N1qlQuery = couchbase.N1qlQuery
+      this.db_config = spice.config.database.connections[connection];
+      this.collection_manager =
+        spice.database.buckets[connection].collections();
+      this.auto_create_collection =
+        auto_create_collection ||
+        ((collection ||
+          spice.config.database.connections[connection].collection) !=
+          undefined &&
+          (collection ||
+            spice.config.database.connections[connection].collection) !=
+            "default" &&
+          (scope || spice.config.database.connections[connection].scope) !=
+            "_default");
+      this.collection_name =
+        collection ||
+        spice.config.database.connections[connection].collection ||
+        "_default";
+      this.scope_name =
+        scope ||
+        spice.config.database.connections[connection].scope ||
+        "_default";
+      this.scope = spice.database.scopes[connection];
+      this.full_text_index =
+        spice.config.database.connections[connection].full_text_index ||
+        full_text_index;
+      this.N1qlQuery = couchbase.N1qlQuery;
       this.SearchQuery = couchbase.SearchQuery;
-    }
-  }
-  connect(key, value) {
-    return new Promise((resolve, reject) => {
-      try {
-        let cluster = new couchbase.Cluster(value.nodes, {
-          username: value.username,
-          password: value.password,
-        });
-        let bucket = cluster.bucket(value.bucket);
-        let collection = bucket.defaultCollection();
-        resolve({
-          connection: key,
-          bucket,
-          cluster,
-          collection,
-        });
-      } catch (e) {
-        spice.logger.debug(e, e.stack);
-        reject(e);
+      this.connection = this.scope.collection(this.collection_name);
+      this.userManager = this.getUserManager(connection);
+      if (this.auto_create_collection) {
+        this.upsertCollection();
       }
-    })
+
+      this.use_bucket_name = !(
+        spice.config.database.connections[this.connection_name].scope &&
+        spice.config.database.connections[this.connection_name].collection
+      );
+    }
   }
 
-  get(doc_id) {
-    let that = this;
-    return new Promise(async function (resolve, reject) {
-      that.connection.get(doc_id, function (err, res) {
-        var return_value = {};
-        if (err) {
-          reject(err);
-        } else {
-          _.defaults(return_value, res.value);
-          return_value.id = doc_id;
-          resolve(return_value);
-        }
-      });
+  async connect(connection_name, config) {
+    let cluster = await couchbase.connect(config.nodes, {
+      username: config.username,
+      password: config.password,
     });
+    let bucket = cluster.bucket(config.bucket);
+    let collection;
+    let scope_name = this.scope_name || config.scope || "_default";
+    let collection_name =
+      this.collection_name || config.collection || "_default";
+    let scope = bucket.scope(scope_name);
+
+    collection = bucket
+      .scope(scope_name)
+      .collection(collection_name || "_default");
+
+    return {
+      connection: connection_name,
+      bucket,
+      cluster,
+      scope,
+      collection,
+    };
   }
 
-  insert(doc_id, document, expiry) {
-    var that = this;
-    return new Promise(async function (resolve, reject) {
-      that.connection.insert(doc_id, document, {
-        expiry: expiry,
-      }, async function (err, res) {
-        if (err) {
-          reject(err);
-        } else {
-          try {
-            let created = await that.get(doc_id)
-            resolve(created)
-          } catch (e) {
-            reject(e)
-          }
-        }
-      });
-    });
+  getUserManager(connection) {
+    return spice.database.clusters[connection].users();
   }
 
-  touch(doc_id, expiry = 0) {
-    var that = this;
-    return new Promise(async function (resolve, reject) {
-      that.connection.touch(doc_id, expiry, async function (err, res) {
-        if (err) {
-          reject(err);
-        } else {
-          try {
-            let created = await that.get(doc_id)
-            resolve(created)
-          } catch (e) {
-            reject(e)
-          }
+  async assignUserPermission() {
+    try {
+      let allUsers = await this.userManager.getAllUsers({ timeout: 6000 });
+      let update_user_response = await this.userManager.upsertUser(
+        this.db_config.username,
+        {
+          roles: [
+            { name: "scope_admin", bucket: this.db_config.bucket },
+            { name: "data_reader", bucket: this.db_config.bucket },
+          ],
         }
-      });
-    });
+      );
+    } catch (e) {
+      console.log(e);
+    }
   }
 
+  getCouchbaseHost(default_port = 8091) {
+    return (
+      (this.db_config.api_base ||
+        `http://${_.last(
+          _.first(this.db_config.nodes.split(",")).split("://")
+        )}`) +
+      ":" +
+      default_port
+    );
+  }
 
-  count(doc_id, adjustment, initial_value) {
-    var that = this;
-    return new Promise(async function (resolve, reject) {
-      that.connection.counter(doc_id, adjustment, {
-        initial: initial_value,
-      }, function (err, res) {
-        if (err) {
-          reject(err);
-        } else {
-          resolve(res.value)
-        }
-      });
-    });
+  //create wait function
+  async wait(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
   }
 
+  async upsertCollection() {
+    try {
+      let collection_exists = await this.collectionExists(
+        this.collection_name,
+        this.scope_name
+      );
+      if (!collection_exists) {
+        await this.createCollection(this.collection_name, this.scope_name);
+        await this.wait(2000);
+        await this.createPrimaryIndex(this.scope_name, this.collection_name);
+      }
+    } catch (e) {
+      console.log(e);
+    }
+  }
 
-  update(doc_id, document) {
-    var that = this;
-    return new Promise(async function (resolve, reject) {
-      that.connection.replace(doc_id, document, function (err, res) {
-        if (err) {
-          reject(err);
-        } else {
-          resolve(res.value)
+  async collectionExists(collection_name, scope_name) {
+    try {
+      let all_scopes = await axios.get(
+        `${this.getCouchbaseHost()}/pools/default/buckets/${
+          this.db_config.bucket
+        }/scopes`,
+        {
+          auth: {
+            username: this.db_config.username,
+            password: this.db_config.password,
+          },
         }
-      });
-    });
+      );
+      let collection_e =
+        _.find(
+          _.find(all_scopes.data.scopes, { name: scope_name })?.collections ||
+            [],
+          { name: collection_name }
+        ) != undefined;
+      return collection_e;
+    } catch (e) {
+      console.log("Exists error happened", e);
+    }
   }
 
-  delete(doc_id) {
-    var that = this;
-    return new Promise(async function (resolve, reject) {
-      that.connection.remove(doc_id, function (err, res) {
-        if (err) {
-          reject(err);
-        } else {
-          resolve(res.value)
-        }
-      });
+  async createCollection(connection_name, scope_name) {
+    try {
+      const token = `${this.db_config.username}:${this.db_config.password}`;
+      const encodedToken = Buffer.from(token).toString("base64");
+      const headers = {
+        Authorization: "Basic " + encodedToken,
+        "Content-Type": "application/x-www-form-urlencoded",
+      };
+      let response = await axios({
+        method: "post",
+        url: `${this.getCouchbaseHost()}/pools/default/buckets/${
+          this.db_config.bucket
+        }/scopes/${scope_name}/collections`,
+        headers,
+        data: qs.stringify({ name: connection_name }),
+      }).data;
+      return response;
+    } catch (e) {}
+  }
+
+  async createPrimaryIndex(scope_name, col_name) {
+    try {
+      let response = await this.query(
+        `CREATE PRIMARY INDEX ON default:\`${this.db_config.bucket}\`.\`${scope_name}\`.\`${col_name}\``
+      );
+      return response;
+    } catch (e) {
+      console.log("CREATE Index :::", e);
+    }
+  }
+
+  async createScope(scope_name) {
+    try {
+      await this.collection_manager.createScope(scope_name);
+    } catch (e) {
+      if (e instanceof couchbase.ScopeExistsError) {
+        console.log("The scope already exists");
+      } else {
+        throw e;
+      }
+    }
+  }
+
+  async get(doc_id) {
+    try {
+      let response = await (this.use_bucket_name
+        ? this.connection
+        : this.collection
+      ).get(doc_id);
+
+      return { id: doc_id, ...response.content };
+    } catch (e) {
+      console.error(e);
+    }
+  }
+
+  async insert(doc_id, document, expiry) {
+    await (this.use_bucket_name ? this.connection : this.collection).insert(
+      doc_id,
+      document,
+      {
+        expiry: expiry,
+      }
+    );
+    return await this.get(doc_id);
+  }
+
+  async touch(doc_id, expiry = 0) {
+    await (this.use_bucket_name ? this.connection : this.collection).touch(
+      doc_id,
+      expiry
+    );
+    return await this.get(doc_id);
+  }
+
+  async count(doc_id, adjustment, initial_value) {
+    let res = await (this.use_bucket_name
+      ? this.connection
+      : this.collection
+    ).counter(doc_id, adjustment, {
+      initial: initial_value,
     });
+    return res.value;
+  }
+
+  async update(doc_id, document) {
+    let res = await (this.use_bucket_name
+      ? this.connection
+      : this.collection
+    ).replace(doc_id, document);
+    return res.value;
+  }
+
+  async delete(doc_id) {
+    let res = await (this.use_bucket_name
+      ? this.connection
+      : this.collection
+    ).remove(doc_id);
+    return res.value;
   }
 
   async multi_get(keys, keep_type) {
@@ -141,8 +290,18 @@ module.exports = class Database {
     }
     // console.log("on Multiget", keys);
     if (_.isArray(keys) && keys.length > 0) {
-      let functions = _.map(keys, key => this.connection.get(key))
-      let responses = await Promise.all(functions);
+      let functions = _.map(keys, (key) =>
+        (this.use_bucket_name ? this.connection : this.collection).get(key)
+      );
+      let returned_all = await Promise.allSettled(functions);
+
+      let responses = _.flatten(
+        _.compact(
+          _.map(returned_all, (returned_obj) => {
+            if (returned_obj.status == "fulfilled") return returned_obj.value;
+          })
+        )
+      );
 
       return _.map(responses, (res, index) => {
         if (!keep_type) {
@@ -151,24 +310,6 @@ module.exports = class Database {
         res.value.id = keys[index];
         return res.value;
       });
-
-      /* that.connection.getMulti(keys, function (err, res) {
-          if (res) {
-            let return_value = [];
-            for (var i in res) {
-              if (res[i].value) {
-                if (!keep_type) {
-                  delete res[i].value['type']
-                }
-                res[i].value.id = i;
-                return_value.push(res[i].value);
-              }
-            }
-            resolve(return_value);
-          } else if (err) {
-            reject(err);
-          }
-        }); */
     } else {
       return [];
     }
@@ -203,7 +344,7 @@ module.exports = class Database {
       that.connection.query(query, async function (err, results, matrix) {
         var return_value = [];
         if (err) {
-          reject(err)
+          reject(err);
         } else {
           for (var i = 0; i < results.length; i++) {
             if (results[i].value) {
@@ -214,88 +355,114 @@ module.exports = class Database {
           }
 
           try {
-            let created = await that.multi_get(return_value)
-            resolve(created)
+            let created = await that.multi_get(return_value);
+            resolve(created);
           } catch (e) {
-            reject(e)
+            reject(e);
           }
         }
       });
     });
   }
 
+  async search(
+    type,
+    columns,
+    query,
+    limit,
+    offset,
+    order_by,
+    do_count,
+    query_scope
+  ) {
+    let is_legacy =
+      this.scope_name !== "_default" && this.collection_name !== "_default";
+    let alias = "_reference";
+    let bucket = `\`${
+      this.use_bucket_name ? this.bucket : this.collection_name
+    }\``;
+
+    try {
+      //let uses_scopes = this.scope this.scope_name !== "_default";
+
+      if (do_count == undefined) {
+        do_count = "false";
+      }
+      var fix = "";
+      var count_query = "";
+      if (!limit) {
+        limit = 0;
+      }
 
-  search(type, columns, query, limit, offset, order_by, do_count, statement_consistent) {
-    let that = this;
-    return new Promise(async (resolve, reject) => {
-      try {
-        if (do_count == undefined) {
-          do_count = "false";
-        }
-        var fix = "";
-        var count_query = "";
-        if (!limit) {
-          limit = 0;
-        }
+      if (!offset) {
+        offset = 0;
+      }
 
-        if (!offset) {
-          offset = 0;
-        }
+      if (columns == "*") {
+        columns = "(" + bucket + ").*";
+        fix = ", META(" + bucket + ").id  AS id";
+      }
 
-        if (columns == "*") {
-          columns = "(" + that.bucket + ").*";
-          fix = ", META(" + that.bucket + ").id  AS id";
-        }
+      if (!columns) {
+        columns = "(" + bucket + ").*";
+        fix = ", META(" + bucket + ").id AS id";
+      }
 
-        if (!columns) {
-          columns = "(" + that.bucket + ").*";
-          fix = ", META(" + that.bucket + ").id AS id";
-        }
+      if (columns == "id") {
+        fix = ", META(" + bucket + ").id AS id";
+        columns = "";
+      }
 
-        if (columns == "id") {
-          fix = ", META(" + that.bucket + ").id AS id";
-          columns = "";
-        }
+      var front_query = `SELECT ${columns} ${fix} FROM ${bucket}`;
 
-        var front_query = "SELECT " + columns + fix + " FROM " + that.bucket + " WHERE type='" + type + "'";
-        count_query = "SELECT count(meta().id) as count FROM " + that.bucket + " WHERE type='" + type + "'";
-        if (query) {
-          count_query = count_query + " AND " + query;
-          query = front_query + " AND " + query;
-        } else {
-          query = front_query;
-        }
+      if (is_legacy || query) {
+        front_query += " WHERE ";
+      }
 
-        if (order_by) {
-          query = `${query} ORDER BY ${order_by}`;
-        }
+      let conditions = [];
+      if (this.use_bucket_name) {
+        conditions.push(`type = '${type}'`);
+      }
+      if (query) {
+        conditions.push(query);
+      }
 
-        if (limit > 0) {
-          query = query + " LIMIT " + limit;
-        }
+      query = front_query + conditions.join(" AND ");
 
-        if (offset > 0) {
-          query = query + " OFFSET " + offset;
-        }
+      count_query = `SELECT count(meta().id) as count FROM ${bucket}`;
+      if (this.use_bucket_name || query) {
+        count_query += " WHERE ";
+      }
+      query = front_query + conditions.join(" AND ");
 
-        var query_element = query;
-        var count_query_element = count_query;
+      if (order_by) {
+        query = `${query} ORDER BY ${order_by}`;
+      }
 
-        let queries = [that.getData(query_element)]
-        if (do_count === "true") {
-          queries.push(that.getCount(count_query_element));
-        }
-        let responses = await Promise.all(queries);
+      if (limit > 0) {
+        query = query + " LIMIT " + limit;
+      }
 
-        resolve({
-          data: responses[0],
-          total: responses.length > 1 ? responses[1] : null,
-        });
-      } catch (error) {
-        console.log(error.stack);
-        reject(error);
+      if (offset > 0) {
+        query = query + " OFFSET " + offset;
       }
-    });
+
+      let active_query_space =
+        query_scope || !this.use_bucket_name ? "scope" : "cluster";
+
+      let queries = [this.getData(query, active_query_space)];
+      if (do_count === "true") {
+        queries.push(this.getCount(count_query, active_query_space));
+      }
+      let responses = await Promise.all(queries);
+
+      return {
+        data: responses[0],
+        total: responses.length > 1 ? responses[1] : null,
+      };
+    } catch (error) {
+      throw error;
+    }
   }
 
   full_text_search(type, search_query, limit, offset = 0, full_text_index) {
@@ -303,7 +470,10 @@ module.exports = class Database {
     return new Promise(async function (resolve, reject) {
       try {
         let full_query = search_query + " AND type:" + type;
-        var query = that.SearchQuery.new(that.full_text_index || full_text_index, that.SearchQuery.queryString(full_query));
+        var query = that.SearchQuery.new(
+          that.full_text_index || full_text_index,
+          that.SearchQuery.queryString(full_query)
+        );
 
         if (!limit) {
           limit = 0;
@@ -322,7 +492,7 @@ module.exports = class Database {
         that.cluster.query(query, async function (err, results, matrix) {
           var return_value = [];
           if (err) {
-            reject(err)
+            reject(err);
           } else {
             for (var i = 0; i < results.length; i++) {
               if (results[i].value) {
@@ -333,7 +503,7 @@ module.exports = class Database {
             }
 
             try {
-              let getted = await that.multi_get(return_value)
+              let getted = await that.multi_get(return_value);
               resolve({
                 data: getted,
                 total: null,
@@ -349,16 +519,21 @@ module.exports = class Database {
     });
   }
 
-  async getCount(count_query_element) {
-    let response = await this.cluster.query(count_query_element);
+  async getCount(count_query_element, query_scope = "cluster") {
+    let response = await this.query(count_query_element, query_scope);
     return response.rows[0].count;
   }
-  async getData(query_element) {
-    let response = await this.cluster.query(query_element)
+  async getData(query_element, query_scope = "cluster") {
+    let response = await this.query(query_element, query_scope);
     return response.rows;
   }
 
-  async query(query) {
-    return this.cluster.query(query)
+  async query(query, query_scope = "cluster") {
+    let scope = query_scope || this.query_scope;
+    if (scope == "cluster") {
+      return await this.cluster.query(query);
+    } else {
+      return await this.scope.query(query);
+    }
   }
-}
+};