spice-couchbase 2.0.44 → 2.0.46

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 {
@@ -305,24 +307,40 @@ module.exports = class Database {
     return _asyncToGenerator(function* () {
       try {
         var useLookupIn = columns.length > 0;
-        var response = yield useLookupIn ? (_this8.use_bucket_name ? _this8.connection : _this8.collection).lookupIn(doc_id, columns.map(col => couchbase.LookupInSpec.get(col))) : (_this8.use_bucket_name ? _this8.connection : _this8.collection).get(doc_id);
+        var collection = _this8.use_bucket_name ? _this8.connection : _this8.collection;
 
-        if (useLookupIn) {
-          // lookupIn returns content array with each spec result
-          var value = {
-            id: doc_id
-          };
-          columns.forEach((col, colIndex) => {
-            if (response.content && response.content[colIndex]) {
-              value[col] = response.content[colIndex].value;
-            }
-          });
-          return value;
-        } else {
+        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
+        };
+
+        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);
       }
@@ -400,42 +418,89 @@ module.exports = class Database {
 
       if (_.isArray(keys) && keys.length > 0) {
         var useLookupIn = columns.length > 0;
+        var collection = _this14.use_bucket_name ? _this14.connection : _this14.collection;
 
-        var functions = _.map(keys, key => useLookupIn ? (_this14.use_bucket_name ? _this14.connection : _this14.collection).lookupIn(key, columns.map(col => couchbase.LookupInSpec.get(col))) : (_this14.use_bucket_name ? _this14.connection : _this14.collection).get(key));
+        if (!useLookupIn) {
+          // Regular get - no batching needed
+          var functions = _.map(keys, key => collection.get(key));
 
-        var returned_all = yield Promise.allSettled(functions);
+          var returned_all = yield Promise.allSettled(functions);
 
-        var responses = _.flatten(_.map(returned_all, returned_obj => {
-          return returned_obj === null || returned_obj === void 0 ? void 0 : returned_obj.value;
-        }));
+          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;
+          var _final_responses = _.compact(_.map(responses, (res, index) => {
+            if (res) {
+              var value = res.value;
 
-            if (useLookupIn) {
-              // lookupIn returns content array with each spec result
-              value = {};
-              columns.forEach((col, colIndex) => {
-                if (res.content && res.content[colIndex]) {
-                  value[col] = res.content[colIndex].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
+
+
+        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;
+                    }
+                  });
                 }
               });
-            } else {
-              // regular get returns the full document in value
-              value = res.value;
-            }
 
-            if (!keep_type && value) {
-              delete value.type;
-            }
+              if (!keep_type && value) {
+                delete value.type;
+              }
 
-            if (value) {
-              value.id = keys[index];
+              return value;
+            } catch (e) {
+              return null;
             }
+          });
+
+          return function (_x) {
+            return _ref.apply(this, arguments);
+          };
+        }());
+
+        var results = yield Promise.allSettled(keyPromises);
 
-            return value;
+        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;
@@ -450,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);
 
@@ -477,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) {
@@ -500,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);
       };
     }());
   }
@@ -611,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));
@@ -632,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) {
@@ -658,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) {
@@ -667,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);
       };
     }());
   }
@@ -692,40 +757,96 @@ module.exports = class Database {
       return response.rows;
     })();
   }
+  /**
+   * Recursively checks if the query plan contains a Fetch operator
+   * @param {Object} plan - The EXPLAIN query plan
+   * @returns {boolean} - True if Fetch operator is found
+   */
+
+
+  hasFetchOperator(plan) {
+    if (!plan || typeof plan !== "object") {
+      return false;
+    } // Check if this node is a Fetch operator
+
+
+    if (plan["#operator"] === "Fetch") {
+      return true;
+    } // Recursively check all child properties
+
+
+    for (var key of Object.keys(plan)) {
+      var value = plan[key];
+
+      if (Array.isArray(value)) {
+        for (var item of value) {
+          if (this.hasFetchOperator(item)) {
+            return true;
+          }
+        }
+      } else if (typeof value === "object" && value !== null) {
+        if (this.hasFetchOperator(value)) {
+          return true;
+        }
+      }
+    }
+
+    return false;
+  }
 
   optimize(query, exec_scope) {
+    var _this18 = this;
+
     return _asyncToGenerator(function* () {
       try {
-        var _$last, _$first, _$first$advice, _$first$advice$advise, _$first$advice$advise2;
+        var _explainResponse$rows;
 
-        var options = {
-          adhoc: true
-        };
-        var advise_query = "ADVISE ".concat(query);
-        var response = yield exec_scope.query(advise_query, options);
-        var best_index = (_$last = _.last(((_$first = _.first((response === null || response === void 0 ? void 0 : response.rows) || [])) === null || _$first === void 0 ? void 0 : (_$first$advice = _$first.advice) === null || _$first$advice === void 0 ? void 0 : (_$first$advice$advise = _$first$advice.adviseinfo) === null || _$first$advice$advise === void 0 ? void 0 : (_$first$advice$advise2 = _$first$advice$advise.recommended_indexes) === null || _$first$advice$advise2 === void 0 ? void 0 : _$first$advice$advise2.indexes) || [])) === null || _$last === void 0 ? void 0 : _$last.index_statement;
+        var {
+          buildCoveringIndex
+        } = require("./utility"); // 1. Run EXPLAIN to get the query plan
+
+
+        var explainQuery = "EXPLAIN ".concat(query);
+        var explainResponse = yield exec_scope.query(explainQuery); // 2. Check if query plan contains Fetch operator (not covered)
 
-        if (best_index) {
-          yield exec_scope.query(best_index);
+        var plan = explainResponse === null || explainResponse === void 0 ? void 0 : (_explainResponse$rows = explainResponse.rows) === null || _explainResponse$rows === void 0 ? void 0 : _explainResponse$rows[0];
+
+        if (!_this18.hasFetchOperator(plan)) {
+          // Query is already covered, no need to create index
+          return;
+        } // 3. Build covering index from the query
+
+
+        var indexStatement = buildCoveringIndex(query, {
+          bucket: _this18.bucket,
+          scope: _this18.scope_name,
+          collection: _this18.collection_name
+        }); // 4. Execute the index creation if we got a valid statement
+
+        if (indexStatement) {
+          console.log("Executing index creation:", indexStatement);
+          var response = yield exec_scope.query(indexStatement);
+          console.log("Index creation response:", response);
         }
-      } catch (e) {}
+      } catch (e) {// Silently handle errors (index may already exist, etc.)
+      }
     })();
   }
 
   query(query) {
-    var _this18 = this;
+    var _this19 = this;
 
     var query_scope = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : "cluster";
     return _asyncToGenerator(function* () {
-      var scope = query_scope || _this18.query_scope;
+      var scope = query_scope || _this19.query_scope;
       var sanitizedQuery = query; //sanitization step to be implemented
 
       var exec_scope = null;
 
       if (scope === "cluster") {
-        exec_scope = _this18.cluster;
+        exec_scope = _this19.cluster;
       } else {
-        exec_scope = _this18.scope;
+        exec_scope = _this19.scope;
       } // Start time
 
 
@@ -738,10 +859,10 @@ module.exports = class Database {
       var endTime = process.hrtime.bigint(); // Calculate duration in microseconds
 
       var durationInMilliseconds = (endTime - startTime) / BigInt(1000000); // optimize if response time is greater than 1 second
+      //if (durationInMilliseconds > 2000) {
+
+      _this19.optimize(query, exec_scope); //}
 
-      if (durationInMilliseconds > 2000) {
-        _this18.optimize(query, exec_scope);
-      }
 
       return response;
     })();