spice-couchbase 2.0.43 → 2.0.45

package/build/index.js

@@ -36,8 +36,10 @@ if (!Promise.allSettled) {
     status: "rejected",
     reason
   }))));
-}
+} // Couchbase lookupIn has a limit of 16 operations per call
 
+
+var LOOKUP_IN_MAX_SPECS = 16;
 module.exports = class Database {
   constructor(connection) {
     var {
@@ -299,12 +301,46 @@ module.exports = class Database {
   get(doc_id) {
     var _this8 = this;
 
+    var {
+      columns = []
+    } = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
     return _asyncToGenerator(function* () {
       try {
-        var response = yield (_this8.use_bucket_name ? _this8.connection : _this8.collection).get(doc_id);
-        return _objectSpread({
+        var useLookupIn = columns.length > 0;
+        var collection = _this8.use_bucket_name ? _this8.connection : _this8.collection;
+
+        if (!useLookupIn) {
+          var response = yield collection.get(doc_id);
+          return _objectSpread({
+            id: doc_id
+          }, response.content);
+        } // Batch columns into chunks of LOOKUP_IN_MAX_SPECS (16)
+
+
+        var value = {
           id: doc_id
-        }, response.content);
+        };
+
+        var columnBatches = _.chunk(columns, LOOKUP_IN_MAX_SPECS); // Execute all batch requests in parallel
+
+
+        var batchPromises = columnBatches.map(batch => {
+          var specs = batch.map(col => couchbase.LookupInSpec.get(col));
+          return collection.lookupIn(doc_id, specs);
+        });
+        var batchResults = yield Promise.allSettled(batchPromises); // Merge results from all batches
+
+        batchResults.forEach((result, batchIndex) => {
+          if (result.status === "fulfilled" && result.value) {
+            var batch = columnBatches[batchIndex];
+            batch.forEach((col, colIndex) => {
+              if (result.value.content && result.value.content[colIndex]) {
+                value[col] = result.value.content[colIndex].value;
+              }
+            });
+          }
+        });
+        return value;
       } catch (e) {
         console.error(e);
       }
@@ -368,33 +404,106 @@ module.exports = class Database {
     })();
   }
 
-  multi_get(keys, keep_type) {
+  multi_get(keys) {
     var _this14 = this;
 
+    var {
+      keep_type = true,
+      columns = []
+    } = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
     return _asyncToGenerator(function* () {
       if (keys.length == 0) {
         return [];
       }
 
       if (_.isArray(keys) && keys.length > 0) {
-        var functions = _.map(keys, key => (_this14.use_bucket_name ? _this14.connection : _this14.collection).get(key));
+        var useLookupIn = columns.length > 0;
+        var collection = _this14.use_bucket_name ? _this14.connection : _this14.collection;
 
-        var returned_all = yield Promise.allSettled(functions);
+        if (!useLookupIn) {
+          // Regular get - no batching needed
+          var functions = _.map(keys, key => collection.get(key));
 
-        var responses = _.flatten(_.map(returned_all, returned_obj => {
-          return returned_obj === null || returned_obj === void 0 ? void 0 : returned_obj.value;
-        }));
+          var returned_all = yield Promise.allSettled(functions);
+
+          var responses = _.flatten(_.map(returned_all, returned_obj => returned_obj === null || returned_obj === void 0 ? void 0 : returned_obj.value));
+
+          var _final_responses = _.compact(_.map(responses, (res, index) => {
+            if (res) {
+              var value = res.value;
+
+              if (!keep_type && value) {
+                delete value.type;
+              }
 
-        return _.compact(_.map(responses, (res, index) => {
-          if (res) {
-            if (!keep_type) {
-              delete res.value.type;
+              if (value) {
+                value.id = keys[index];
+              }
+
+              return value;
+            }
+          }));
+
+          return _final_responses;
+        } // lookupIn with batching for columns > 16
+
+
+        var columnBatches = _.chunk(columns, LOOKUP_IN_MAX_SPECS); // For each key, we need to fetch all column batches and merge the results
+
+
+        var keyPromises = _.map(keys,
+        /*#__PURE__*/
+        function () {
+          var _ref = _asyncToGenerator(function* (key) {
+            try {
+              var value = {
+                id: key
+              }; // Execute all batch requests for this key in parallel
+
+              var batchPromises = columnBatches.map(batch => {
+                var specs = batch.map(col => couchbase.LookupInSpec.get(col));
+                return collection.lookupIn(key, specs);
+              });
+              var batchResults = yield Promise.allSettled(batchPromises); // Merge results from all batches
+
+              batchResults.forEach((result, batchIndex) => {
+                if (result.status === "fulfilled" && result.value) {
+                  var batch = columnBatches[batchIndex];
+                  batch.forEach((col, colIndex) => {
+                    if (result.value.content && result.value.content[colIndex]) {
+                      value[col] = result.value.content[colIndex].value;
+                    }
+                  });
+                }
+              });
+
+              if (!keep_type && value) {
+                delete value.type;
+              }
+
+              return value;
+            } catch (e) {
+              return null;
             }
+          });
 
-            res.value.id = keys[index];
-            return res.value;
+          return function (_x) {
+            return _ref.apply(this, arguments);
+          };
+        }());
+
+        var results = yield Promise.allSettled(keyPromises);
+
+        var final_responses = _.compact(_.map(results, result => {
+          if (result.status === "fulfilled" && result.value) {
+            // Only return if we got at least some data beyond just the id
+            return Object.keys(result.value).length > 1 ? result.value : null;
           }
+
+          return null;
         }));
+
+        return final_responses;
       } else {
         return [];
       }
@@ -406,7 +515,7 @@ module.exports = class Database {
     return new Promise(
     /*#__PURE__*/
     function () {
-      var _ref = _asyncToGenerator(function* (resolve, reject) {
+      var _ref2 = _asyncToGenerator(function* (resolve, reject) {
         var ViewQuery = couchbase.ViewQuery;
         var query = ViewQuery.from(design_doc, view);
 
@@ -433,7 +542,7 @@ module.exports = class Database {
         that.connection.query(query,
         /*#__PURE__*/
         function () {
-          var _ref2 = _asyncToGenerator(function* (err, results, matrix) {
+          var _ref3 = _asyncToGenerator(function* (err, results, matrix) {
             var return_value = [];
 
             if (err) {
@@ -456,14 +565,14 @@ module.exports = class Database {
             }
           });
 
-          return function (_x3, _x4, _x5) {
-            return _ref2.apply(this, arguments);
+          return function (_x4, _x5, _x6) {
+            return _ref3.apply(this, arguments);
           };
         }());
       });
 
-      return function (_x, _x2) {
-        return _ref.apply(this, arguments);
+      return function (_x2, _x3) {
+        return _ref2.apply(this, arguments);
       };
     }());
   }
@@ -567,7 +676,7 @@ module.exports = class Database {
     return new Promise(
     /*#__PURE__*/
     function () {
-      var _ref3 = _asyncToGenerator(function* (resolve, reject) {
+      var _ref4 = _asyncToGenerator(function* (resolve, reject) {
         try {
           var full_query = search_query + " AND type:" + type;
           var query = that.SearchQuery.new(that.full_text_index || full_text_index, that.SearchQuery.queryString(full_query));
@@ -588,7 +697,7 @@ module.exports = class Database {
           that.cluster.query(query,
           /*#__PURE__*/
           function () {
-            var _ref4 = _asyncToGenerator(function* (err, results, matrix) {
+            var _ref5 = _asyncToGenerator(function* (err, results, matrix) {
               var return_value = [];
 
               if (err) {
@@ -614,8 +723,8 @@ module.exports = class Database {
               }
             });
 
-            return function (_x8, _x9, _x10) {
-              return _ref4.apply(this, arguments);
+            return function (_x9, _x10, _x11) {
+              return _ref5.apply(this, arguments);
             };
           }());
         } catch (e) {
@@ -623,8 +732,8 @@ module.exports = class Database {
         }
       });
 
-      return function (_x6, _x7) {
-        return _ref3.apply(this, arguments);
+      return function (_x7, _x8) {
+        return _ref4.apply(this, arguments);
       };
     }());
   }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "spice-couchbase",
-  "version": "2.0.43",
+  "version": "2.0.45",
   "description": "",
   "main": "build/index.js",
   "scripts": {
@@ -10,7 +10,7 @@
   "license": "ISC",
   "dependencies": {
     "axios": "^0.26.1",
-    "couchbase": "^4.2.7",
+    "couchbase": "^4.6.0",
     "lodash": "^4.17.15",
     "qs": "^6.10.3"
   },

package/src/index.js

@@ -24,6 +24,9 @@ if (!Promise.allSettled) {
     );
 }
 
+// Couchbase lookupIn has a limit of 16 operations per call
+const LOOKUP_IN_MAX_SPECS = 16;
+
 module.exports = class Database {
   constructor(
     connection,
@@ -265,13 +268,41 @@ module.exports = class Database {
     }
   }
 
-  async get(doc_id) {
+  async get(doc_id, { columns = [] } = {}) {
     try {
-      let response = await (
-        this.use_bucket_name ? this.connection : this.collection
-      ).get(doc_id);
+      const useLookupIn = columns.length > 0;
+      const collection = this.use_bucket_name ? this.connection : this.collection;
+
+      if (!useLookupIn) {
+        let response = await collection.get(doc_id);
+        return { id: doc_id, ...response.content };
+      }
+
+      // Batch columns into chunks of LOOKUP_IN_MAX_SPECS (16)
+      let value = { id: doc_id };
+      const columnBatches = _.chunk(columns, LOOKUP_IN_MAX_SPECS);
+
+      // Execute all batch requests in parallel
+      const batchPromises = columnBatches.map((batch) => {
+        const specs = batch.map((col) => couchbase.LookupInSpec.get(col));
+        return collection.lookupIn(doc_id, specs);
+      });
+
+      const batchResults = await Promise.allSettled(batchPromises);
+
+      // Merge results from all batches
+      batchResults.forEach((result, batchIndex) => {
+        if (result.status === "fulfilled" && result.value) {
+          const batch = columnBatches[batchIndex];
+          batch.forEach((col, colIndex) => {
+            if (result.value.content && result.value.content[colIndex]) {
+              value[col] = result.value.content[colIndex].value;
+            }
+          });
+        }
+      });
 
-      return { id: doc_id, ...response.content };
+      return value;
     } catch (e) {
       console.error(e);
     }
@@ -302,8 +333,9 @@ module.exports = class Database {
 
   async count(doc_id, adjustment, initial_value) {
     let res = await (
-      this.use_bucket_name ? this.connection : this.collection
-    ).counter(doc_id, adjustment, {
+      this.use_bucket_name ?
+        this.connection
+      : this.collection).counter(doc_id, adjustment, {
       initial: initial_value,
     });
     return res.value;
@@ -311,8 +343,9 @@ module.exports = class Database {
 
   async update(doc_id, document, expiry) {
     let res = await (
-      this.use_bucket_name ? this.connection : this.collection
-    ).replace(doc_id, document, {
+      this.use_bucket_name ?
+        this.connection
+      : this.collection).replace(doc_id, document, {
       expiry: expiry,
     });
     return res.value;
@@ -320,38 +353,97 @@ module.exports = class Database {
 
   async delete(doc_id) {
     let res = await (
-      this.use_bucket_name ? this.connection : this.collection
-    ).remove(doc_id);
+      this.use_bucket_name ?
+        this.connection
+      : this.collection).remove(doc_id);
     return res.value;
   }
 
-  async multi_get(keys, keep_type) {
+  async multi_get(keys, { keep_type = true, columns = [] } = {}) {
     if (keys.length == 0) {
       return [];
     }
     if (_.isArray(keys) && keys.length > 0) {
-      let functions = _.map(keys, (key) =>
-        (this.use_bucket_name ? this.connection : this.collection).get(key)
-      );
-      let returned_all = await Promise.allSettled(functions);
+      const useLookupIn = columns.length > 0;
+      const collection = this.use_bucket_name ? this.connection : this.collection;
 
-      let responses = _.flatten(
-        _.map(returned_all, (returned_obj) => {
-          return returned_obj?.value;
-        })
-      );
+      if (!useLookupIn) {
+        // Regular get - no batching needed
+        let functions = _.map(keys, (key) => collection.get(key));
+        let returned_all = await Promise.allSettled(functions);
+
+        let responses = _.flatten(
+          _.map(returned_all, (returned_obj) => returned_obj?.value)
+        );
 
-      return _.compact(
-        _.map(responses, (res, index) => {
-          if (res) {
-            if (!keep_type) {
-              delete res.value.type;
+        let final_responses = _.compact(
+          _.map(responses, (res, index) => {
+            if (res) {
+              let value = res.value;
+              if (!keep_type && value) {
+                delete value.type;
+              }
+              if (value) {
+                value.id = keys[index];
+              }
+              return value;
+            }
+          })
+        );
+
+        return final_responses;
+      }
+
+      // lookupIn with batching for columns > 16
+      const columnBatches = _.chunk(columns, LOOKUP_IN_MAX_SPECS);
+
+      // For each key, we need to fetch all column batches and merge the results
+      const keyPromises = _.map(keys, async (key) => {
+        try {
+          let value = { id: key };
+
+          // Execute all batch requests for this key in parallel
+          const batchPromises = columnBatches.map((batch) => {
+            const specs = batch.map((col) => couchbase.LookupInSpec.get(col));
+            return collection.lookupIn(key, specs);
+          });
+
+          const batchResults = await Promise.allSettled(batchPromises);
+
+          // Merge results from all batches
+          batchResults.forEach((result, batchIndex) => {
+            if (result.status === "fulfilled" && result.value) {
+              const batch = columnBatches[batchIndex];
+              batch.forEach((col, colIndex) => {
+                if (result.value.content && result.value.content[colIndex]) {
+                  value[col] = result.value.content[colIndex].value;
+                }
+              });
             }
-            res.value.id = keys[index];
-            return res.value;
+          });
+
+          if (!keep_type && value) {
+            delete value.type;
           }
+
+          return value;
+        } catch (e) {
+          return null;
+        }
+      });
+
+      let results = await Promise.allSettled(keyPromises);
+      let final_responses = _.compact(
+        _.map(results, (result) => {
+          if (result.status === "fulfilled" && result.value) {
+            // Only return if we got at least some data beyond just the id
+            return Object.keys(result.value).length > 1 ? result.value : null;
+          }
+          return null;
         })
       );
+
+      return final_responses;
     } else {
       return [];
     }