spice-couchbase 2.0.53 → 2.0.55

package/build/index.js

@@ -34,6 +34,56 @@ if (!Promise.allSettled) {
 
 
 var LOOKUP_IN_MAX_SPECS = 16;
+
+function normalizeScanConsistency(value) {
+  if (value === true || value === QueryScanConsistency.RequestPlus || typeof value === "string" && ["true", "request_plus"].includes(value.toLowerCase())) {
+    return QueryScanConsistency.RequestPlus;
+  }
+
+  if (value === undefined || value === null || value === "" || value === false || value === QueryScanConsistency.NotBounded || typeof value === "string" && ["false", "not_bounded"].includes(value.toLowerCase())) {
+    return QueryScanConsistency.NotBounded;
+  }
+
+  throw new Error("Unsupported query scan consistency: ".concat(value));
+}
+
+function buildQueryOptions() {
+  var _queryOptions$consist, _queryOptions$scanWai;
+
+  var queryOptions = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+
+  if (typeof queryOptions !== "object" || Array.isArray(queryOptions)) {
+    queryOptions = {
+      scan_consistency: queryOptions
+    };
+  }
+
+  var options = {};
+  var consistentWith = (_queryOptions$consist = queryOptions.consistentWith) !== null && _queryOptions$consist !== void 0 ? _queryOptions$consist : queryOptions.consistent_with;
+
+  if (consistentWith !== undefined && consistentWith !== null) {
+    options.consistentWith = consistentWith;
+  } else {
+    var _queryOptions$scanCon;
+
+    options.scanConsistency = normalizeScanConsistency((_queryOptions$scanCon = queryOptions.scanConsistency) !== null && _queryOptions$scanCon !== void 0 ? _queryOptions$scanCon : queryOptions.scan_consistency);
+  }
+
+  var scanWait = (_queryOptions$scanWai = queryOptions.scanWait) !== null && _queryOptions$scanWai !== void 0 ? _queryOptions$scanWai : queryOptions.scan_wait;
+
+  if (scanWait !== undefined && scanWait !== null && scanWait !== "") {
+    var numericScanWait = Number(scanWait);
+
+    if (!Number.isFinite(numericScanWait) || numericScanWait < 0) {
+      throw new Error("Invalid query scan wait: ".concat(scanWait));
+    }
+
+    options.scanWait = numericScanWait;
+  }
+
+  return options;
+}
+
 module.exports = class Database {
   constructor(connection) {
     var {
@@ -178,10 +228,10 @@ module.exports = class Database {
   }
 
   isCollectionAlreadyExistsError(error) {
-    var _error$cause, _error$cause2, _error$context, _error$context2;
+    var _error$cause, _error$context, _error$context2, _error$cause2, _error$cause3;
 
     var message = (error === null || error === void 0 ? void 0 : error.message) || (error === null || error === void 0 ? void 0 : (_error$cause = error.cause) === null || _error$cause === void 0 ? void 0 : _error$cause.first_error_message) || (error === null || error === void 0 ? void 0 : (_error$context = error.context) === null || _error$context === void 0 ? void 0 : _error$context.first_error_message) || (error === null || error === void 0 ? void 0 : (_error$context2 = error.context) === null || _error$context2 === void 0 ? void 0 : _error$context2.http_response_body) || "";
-    return error instanceof couchbase.CollectionExistsError || (error === null || error === void 0 ? void 0 : (_error$cause2 = error.cause) === null || _error$cause2 === void 0 ? void 0 : _error$cause2.first_error_code) === 12003 || (error === null || error === void 0 ? void 0 : (_error$cause2 = error.cause) === null || _error$cause2 === void 0 ? void 0 : _error$cause2.first_error_code) === 12027 || /collection .*already exists|already exists/i.test(message);
+    return error instanceof couchbase.CollectionExistsError || (error === null || error === void 0 ? void 0 : (_error$cause2 = error.cause) === null || _error$cause2 === void 0 ? void 0 : _error$cause2.first_error_code) === 12003 || (error === null || error === void 0 ? void 0 : (_error$cause3 = error.cause) === null || _error$cause3 === void 0 ? void 0 : _error$cause3.first_error_code) === 12027 || /collection .*already exists|already exists/i.test(message);
   }
 
   upsertCollection() {
@@ -283,9 +333,9 @@ module.exports = class Database {
         var response = yield _this7.query("CREATE PRIMARY INDEX ON ".concat(_this7.collectionPath(scope_name, col_name)));
         return response;
       } catch (e) {
-        var _e$cause3, _e$cause4;
+        var _e$cause, _e$cause2;
 
-        if (e instanceof couchbase.IndexExistsError || (e === null || e === void 0 ? void 0 : (_e$cause3 = e.cause) === null || _e$cause3 === void 0 ? void 0 : _e$cause3.first_error_code) === 4300 || /index .*already exists|index_exists/i.test((e === null || e === void 0 ? void 0 : e.message) || (e === null || e === void 0 ? void 0 : (_e$cause4 = e.cause) === null || _e$cause4 === void 0 ? void 0 : _e$cause4.first_error_message) || "")) {
+        if (e instanceof couchbase.IndexExistsError || (e === null || e === void 0 ? void 0 : (_e$cause = e.cause) === null || _e$cause === void 0 ? void 0 : _e$cause.first_error_code) === 4300 || /index .*already exists|index_exists/i.test((e === null || e === void 0 ? void 0 : e.message) || (e === null || e === void 0 ? void 0 : (_e$cause2 = e.cause) === null || _e$cause2 === void 0 ? void 0 : _e$cause2.first_error_message) || "")) {
           return;
         }
 
@@ -600,6 +650,7 @@ module.exports = class Database {
     var do_count = arguments.length > 6 && arguments[6] !== undefined ? arguments[6] : "false";
     var query_scope = arguments.length > 7 ? arguments[7] : undefined;
     var join = arguments.length > 8 && arguments[8] !== undefined ? arguments[8] : "";
+    var query_options = arguments.length > 9 && arguments[9] !== undefined ? arguments[9] : {};
     return _asyncToGenerator(function* () {
       var is_legacy = _this16.scope_name !== "_default" && _this16.collection_name !== "_default";
       var bucket = "`".concat(_this16.use_bucket_name ? _this16.bucket : _this16.collection_name, "`");
@@ -663,11 +714,11 @@ module.exports = class Database {
         var limit_clause = limit > 0 ? " LIMIT ".concat(limit) : "";
         var offset_clause = offset > 0 ? " OFFSET ".concat(offset) : "";
         query = query + order_by_clause + limit_clause + offset_clause;
-        var active_query_space = query_scope || !_this16.use_bucket_name ? "scope" : "cluster";
-        var queries = [_this16.getData(query, active_query_space)];
+        var active_query_space = query_scope || (!_this16.use_bucket_name ? "scope" : "cluster");
+        var queries = [_this16.getData(query, active_query_space, query_options)];
 
         if (do_count != "false") {
-          queries.push(_this16.getCount(count_query, active_query_space));
+          queries.push(_this16.getCount(count_query, active_query_space, query_options));
         }
 
         var responses = yield Promise.all(queries);
@@ -754,8 +805,9 @@ module.exports = class Database {
     var _this17 = this;
 
     var query_scope = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : "cluster";
+    var query_options = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
     return _asyncToGenerator(function* () {
-      var response = yield _this17.query(count_query_element, query_scope);
+      var response = yield _this17.query(count_query_element, query_scope, query_options);
       return response.rows[0].count;
     })();
   }
@@ -764,8 +816,9 @@ module.exports = class Database {
     var _this18 = this;
 
     var query_scope = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : "cluster";
+    var query_options = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
     return _asyncToGenerator(function* () {
-      var response = yield _this18.query(query_element, query_scope);
+      var response = yield _this18.query(query_element, query_scope, query_options);
       return response.rows;
     })();
   }
@@ -843,12 +896,17 @@ module.exports = class Database {
     })();
   }
 
-  query(query) {
+  query(query, query_scope) {
     var _this20 = this;
 
-    var query_scope = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : "cluster";
+    var query_options = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
     return _asyncToGenerator(function* () {
-      var scope = query_scope || _this20.query_scope;
+      if (query_scope && typeof query_scope === "object" && !Array.isArray(query_scope)) {
+        query_options = query_scope;
+        query_scope = undefined;
+      }
+
+      var scope = query_scope || _this20.query_scope || "cluster";
       var sanitizedQuery = query; //sanitization step to be implemented
 
       var exec_scope = null;
@@ -861,16 +919,14 @@ module.exports = class Database {
 
 
       var startTime = process.hrtime.bigint();
-      var options = {
-        scanConsistency: QueryScanConsistency.RequestPlus
-      };
+      var options = buildQueryOptions(query_options);
       var response = yield exec_scope.query(sanitizedQuery, options); // End time
 
       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) {
+      if (durationInMilliseconds > 1000) {
         _this20.optimize(query, exec_scope);
       }
 
@@ -878,4 +934,4 @@ module.exports = class Database {
     })();
   }
 
-};
+};

package/build/index.query-consistency.test.js

@@ -0,0 +1,229 @@
+"use strict";
+
+function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) { try { var info = gen[key](arg); var value = info.value; } catch (error) { reject(error); return; } if (info.done) { resolve(value); } else { Promise.resolve(value).then(_next, _throw); } }
+
+function _asyncToGenerator(fn) { return function () { var self = this, args = arguments; return new Promise(function (resolve, reject) { var gen = fn.apply(self, args); function _next(value) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value); } function _throw(err) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err); } _next(undefined); }); }; }
+
+var assert = require("assert");
+
+var {
+  QueryScanConsistency
+} = require("couchbase");
+
+var Database = require("./index");
+
+var passed = 0;
+var failed = 0;
+
+function createQueryDb() {
+  var calls = [];
+  var db = Object.create(Database.prototype);
+  db.query_scope = "cluster";
+  db.cluster = {
+    query: function () {
+      var _query = _asyncToGenerator(function* (statement, options) {
+        calls.push({
+          target: "cluster",
+          statement,
+          options
+        });
+        return {
+          rows: []
+        };
+      });
+
+      function query(_x, _x2) {
+        return _query.apply(this, arguments);
+      }
+
+      return query;
+    }()
+  };
+  db.scope = {
+    query: function () {
+      var _query2 = _asyncToGenerator(function* (statement, options) {
+        calls.push({
+          target: "scope",
+          statement,
+          options
+        });
+        return {
+          rows: []
+        };
+      });
+
+      function query(_x3, _x4) {
+        return _query2.apply(this, arguments);
+      }
+
+      return query;
+    }()
+  };
+
+  db.optimize = () => {};
+
+  return {
+    db,
+    calls
+  };
+}
+
+function test(_x5, _x6) {
+  return _test.apply(this, arguments);
+}
+
+function _test() {
+  _test = _asyncToGenerator(function* (name, fn) {
+    try {
+      yield fn();
+      console.log("\u2713 ".concat(name));
+      passed += 1;
+    } catch (error) {
+      console.log("\u2717 ".concat(name));
+      console.log("  Error: ".concat(error.stack || error.message));
+      failed += 1;
+    }
+  });
+  return _test.apply(this, arguments);
+}
+
+function run() {
+  return _run.apply(this, arguments);
+}
+
+function _run() {
+  _run = _asyncToGenerator(function* () {
+    console.log("\n--- query consistency tests ---");
+    yield test("ordinary SQL++ queries default to not_bounded",
+    /*#__PURE__*/
+    _asyncToGenerator(function* () {
+      var {
+        db,
+        calls
+      } = createQueryDb();
+      yield db.query("SELECT 1");
+      assert.strictEqual(calls[0].target, "cluster");
+      assert.strictEqual(calls[0].options.scanConsistency, QueryScanConsistency.NotBounded);
+    }));
+    yield test("request_plus can be selected explicitly",
+    /*#__PURE__*/
+    _asyncToGenerator(function* () {
+      var {
+        db,
+        calls
+      } = createQueryDb();
+      yield db.query("SELECT 1", "scope", {
+        scan_consistency: "request_plus",
+        scan_wait: 2500
+      });
+      assert.strictEqual(calls[0].target, "scope");
+      assert.strictEqual(calls[0].options.scanConsistency, QueryScanConsistency.RequestPlus);
+      assert.strictEqual(calls[0].options.scanWait, 2500);
+    }));
+    yield test("legacy boolean consistency values remain supported",
+    /*#__PURE__*/
+    _asyncToGenerator(function* () {
+      var {
+        db,
+        calls
+      } = createQueryDb();
+      yield db.query("SELECT 1", "cluster", {
+        scan_consistency: true
+      });
+      assert.strictEqual(calls[0].options.scanConsistency, QueryScanConsistency.RequestPlus);
+    }));
+    yield test("mutation state is forwarded without a conflicting scan mode",
+    /*#__PURE__*/
+    _asyncToGenerator(function* () {
+      var {
+        db,
+        calls
+      } = createQueryDb();
+      var mutationState = {
+        token: "test-token"
+      };
+      yield db.query("SELECT 1", {
+        consistent_with: mutationState,
+        scan_wait: 1000
+      });
+      assert.strictEqual(calls[0].options.consistentWith, mutationState);
+      assert.strictEqual(calls[0].options.scanConsistency, undefined);
+      assert.strictEqual(calls[0].options.scanWait, 1000);
+    }));
+    yield test("search keeps query scope separate from consistency",
+    /*#__PURE__*/
+    _asyncToGenerator(function* () {
+      var db = Object.create(Database.prototype);
+      var calls = [];
+      db.use_bucket_name = true;
+      db.bucket = "documents";
+      db.scope_name = "_default";
+      db.collection_name = "_default";
+
+      db.getData =
+      /*#__PURE__*/
+      function () {
+        var _ref6 = _asyncToGenerator(function* (statement, scope, options) {
+          calls.push({
+            kind: "data",
+            statement,
+            scope,
+            options
+          });
+          return [];
+        });
+
+        return function (_x7, _x8, _x9) {
+          return _ref6.apply(this, arguments);
+        };
+      }();
+
+      db.getCount =
+      /*#__PURE__*/
+      function () {
+        var _ref7 = _asyncToGenerator(function* (statement, scope, options) {
+          calls.push({
+            kind: "count",
+            statement,
+            scope,
+            options
+          });
+          return 0;
+        });
+
+        return function (_x10, _x11, _x12) {
+          return _ref7.apply(this, arguments);
+        };
+      }();
+
+      var options = {
+        scan_consistency: "request_plus"
+      };
+      yield db.search("application", "", "", 10, 0, "created_at DESC", "true", "cluster", "", options);
+      assert.deepStrictEqual(calls.map(call => call.scope), ["cluster", "cluster"]);
+      assert.strictEqual(calls[0].options, options);
+      assert.strictEqual(calls[1].options, options);
+    }));
+    yield test("invalid consistency values fail before issuing a query",
+    /*#__PURE__*/
+    _asyncToGenerator(function* () {
+      var {
+        db,
+        calls
+      } = createQueryDb();
+      yield assert.rejects(() => db.query("SELECT 1", "cluster", {
+        scan_consistency: "eventual"
+      }), /Unsupported query scan consistency/);
+      assert.strictEqual(calls.length, 0);
+    }));
+    console.log("\nPassed: ".concat(passed));
+    console.log("Failed: ".concat(failed));
+    if (failed > 0) process.exitCode = 1;
+  });
+  return _run.apply(this, arguments);
+}
+
+run().catch(error => {
+  console.error(error);
+  process.exit(1);
+});

package/build/utility.js

@@ -284,8 +284,21 @@ function splitSelectClause(clause) {
 
   return parts;
 }
+
+function hasQualifiedWildcardProjection(query) {
+  var selectMatch = query.match(/\bSELECT\b([\s\S]+?)\bFROM\b/i);
+
+  if (!selectMatch) {
+    return false;
+  }
+
+  return splitSelectClause(selectMatch[1].trim()).some(part => {
+    var trimmedPart = part.trim();
+    return /^\(\s*`?\w+`?\s*\)\s*\.\s*\*$/.test(trimmedPart) || /^`?\w+`?\s*\.\s*\*$/.test(trimmedPart);
+  });
+}
 /**
- * Builds a covering index CREATE statement from a query
+ * Builds a covering or fallback non-covering index CREATE statement from a query
  * @param {string} query - The N1QL query to analyze
  * @param {Object} options - Configuration options
  * @param {string} options.bucket - The bucket name
@@ -298,19 +311,19 @@ function splitSelectClause(clause) {
 function buildCoveringIndex(query, options) {
   var {
     bucket,
-    scope,
-    collection
+    scope = "_default",
+    collection = "_default"
   } = options;
 
-  if (!bucket || !scope || !collection) {
+  if (!bucket) {
     return null;
   } // Extract fields from SELECT clause
 
 
   var selectFields = extractSelectFields(query);
+  var isNonCoveringFallback = selectFields === null && hasQualifiedWildcardProjection(query);
 
-  if (selectFields === null) {
-    // SELECT * query - cannot create covering index
+  if (selectFields === null && !isNonCoveringFallback) {
     return null;
   } // Extract fields from WHERE clause
 
@@ -349,7 +362,7 @@ function buildCoveringIndex(query, options) {
     return true;
   }); // Filter SELECT fields (remove duplicates from WHERE, GROUP BY, and ORDER BY, remove deleted)
 
-  var selectFieldsFiltered = selectFields.filter(f => {
+  var selectFieldsFiltered = (selectFields || []).filter(f => {
     var lower = f.toLowerCase();
 
     if (addedFields.has(lower) || lower === "deleted") {
@@ -373,9 +386,10 @@ function buildCoveringIndex(query, options) {
 
   var indexFieldsKey = allFields.map(field => formatIndexKey(field, orderDirectionMap)).sort().join(",");
   var orderFieldsKey = orderByIndexFields.map(field => formatIndexKey(field.name, orderDirectionMap)).join(",");
-  var indexKey = "".concat(bucket, "|").concat(scope, "|").concat(collection, "|fields:").concat(indexFieldsKey, "|order:").concat(orderFieldsKey);
+  var indexMode = isNonCoveringFallback ? "noncovered" : "covered";
+  var indexKey = "".concat(bucket, "|").concat(scope, "|").concat(collection, "|mode:").concat(indexMode, "|fields:").concat(indexFieldsKey, "|order:").concat(orderFieldsKey);
   var hash = generateHash(indexKey);
-  var indexName = "adv_covered_".concat(hash); // Build the CREATE INDEX statement
+  var indexName = "adv_".concat(indexMode, "_").concat(hash); // Build the CREATE INDEX statement
 
   var indexStatement = "CREATE INDEX `".concat(indexName, "` ON `default`:`").concat(bucket, "`.`").concat(scope, "`.`").concat(collection, "`(").concat(fieldList, ")");
   return indexStatement;

package/package.json

@@ -1,10 +1,11 @@
 {
   "name": "spice-couchbase",
-  "version": "2.0.53",
+  "version": "2.0.55",
   "description": "",
   "main": "build/index.js",
   "scripts": {
-    "test": "node src/utility.test.js"
+    "test": "node src/utility.test.js",
+    "test:query-consistency": "node src/index.query-consistency.test.js"
   },
   "author": "Chad Fraser <chad@sonover.com> (http://sonover.com)",
   "license": "ISC",

package/src/index.js

@@ -25,6 +25,60 @@ if (!Promise.allSettled) {
 // Couchbase lookupIn has a limit of 16 operations per call
 const LOOKUP_IN_MAX_SPECS = 16;
 
+function normalizeScanConsistency(value) {
+  if (
+    value === true ||
+    value === QueryScanConsistency.RequestPlus ||
+    (typeof value === "string" &&
+      ["true", "request_plus"].includes(value.toLowerCase()))
+  ) {
+    return QueryScanConsistency.RequestPlus;
+  }
+
+  if (
+    value === undefined ||
+    value === null ||
+    value === "" ||
+    value === false ||
+    value === QueryScanConsistency.NotBounded ||
+    (typeof value === "string" &&
+      ["false", "not_bounded"].includes(value.toLowerCase()))
+  ) {
+    return QueryScanConsistency.NotBounded;
+  }
+
+  throw new Error(`Unsupported query scan consistency: ${value}`);
+}
+
+function buildQueryOptions(queryOptions = {}) {
+  if (typeof queryOptions !== "object" || Array.isArray(queryOptions)) {
+    queryOptions = { scan_consistency: queryOptions };
+  }
+
+  const options = {};
+  const consistentWith =
+    queryOptions.consistentWith ?? queryOptions.consistent_with;
+
+  if (consistentWith !== undefined && consistentWith !== null) {
+    options.consistentWith = consistentWith;
+  } else {
+    options.scanConsistency = normalizeScanConsistency(
+      queryOptions.scanConsistency ?? queryOptions.scan_consistency,
+    );
+  }
+
+  const scanWait = queryOptions.scanWait ?? queryOptions.scan_wait;
+  if (scanWait !== undefined && scanWait !== null && scanWait !== "") {
+    const numericScanWait = Number(scanWait);
+    if (!Number.isFinite(numericScanWait) || numericScanWait < 0) {
+      throw new Error(`Invalid query scan wait: ${scanWait}`);
+    }
+    options.scanWait = numericScanWait;
+  }
+
+  return options;
+}
+
 module.exports = class Database {
   constructor(
     connection,
@@ -249,9 +303,7 @@ module.exports = class Database {
       spice.db.collections.add(connection_name);
       return response;
     } catch (e) {
-      if (
-        this.isCollectionAlreadyExistsError(e)
-      ) {
+      if (this.isCollectionAlreadyExistsError(e)) {
         spice.db.collections.add(connection_name);
         return;
       }
@@ -559,6 +611,7 @@ module.exports = class Database {
     do_count = "false",
     query_scope,
     join = "",
+    query_options = {},
   ) {
     const is_legacy =
       this.scope_name !== "_default" && this.collection_name !== "_default";
@@ -630,10 +683,14 @@ module.exports = class Database {
       query = query + order_by_clause + limit_clause + offset_clause;
 
       const active_query_space =
-        query_scope || !this.use_bucket_name ? "scope" : "cluster";
-      const queries = [this.getData(query, active_query_space)];
+        query_scope || (!this.use_bucket_name ? "scope" : "cluster");
+      const queries = [
+        this.getData(query, active_query_space, query_options),
+      ];
       if (do_count != "false") {
-        queries.push(this.getCount(count_query, active_query_space));
+        queries.push(
+          this.getCount(count_query, active_query_space, query_options),
+        );
       }
       const responses = await Promise.all(queries);
 
@@ -700,12 +757,20 @@ module.exports = class Database {
     });
   }
 
-  async getCount(count_query_element, query_scope = "cluster") {
-    let response = await this.query(count_query_element, query_scope);
+  async getCount(
+    count_query_element,
+    query_scope = "cluster",
+    query_options = {},
+  ) {
+    let response = await this.query(
+      count_query_element,
+      query_scope,
+      query_options,
+    );
     return response.rows[0].count;
   }
-  async getData(query_element, query_scope = "cluster") {
-    let response = await this.query(query_element, query_scope);
+  async getData(query_element, query_scope = "cluster", query_options = {}) {
+    let response = await this.query(query_element, query_scope, query_options);
     return response.rows;
   }
 
@@ -774,8 +839,17 @@ module.exports = class Database {
     }
   }
 
-  async query(query, query_scope = "cluster") {
-    let scope = query_scope || this.query_scope;
+  async query(query, query_scope, query_options = {}) {
+    if (
+      query_scope &&
+      typeof query_scope === "object" &&
+      !Array.isArray(query_scope)
+    ) {
+      query_options = query_scope;
+      query_scope = undefined;
+    }
+
+    let scope = query_scope || this.query_scope || "cluster";
     const sanitizedQuery = query; //sanitization step to be implemented
     let exec_scope = null;
 
@@ -786,16 +860,14 @@ module.exports = class Database {
     }
     // Start time
     let startTime = process.hrtime.bigint();
-    const options = {
-      scanConsistency: QueryScanConsistency.RequestPlus,
-    };
+    const options = buildQueryOptions(query_options);
     let response = await exec_scope.query(sanitizedQuery, options);
     // End time
     let endTime = process.hrtime.bigint();
     // Calculate duration in microseconds
     let durationInMilliseconds = (endTime - startTime) / BigInt(1000000);
     // optimize if response time is greater than 1 second
-    if (durationInMilliseconds > 2000) {
+    if (durationInMilliseconds > 1000) {
       this.optimize(query, exec_scope);
     }
     return response;

package/src/index.query-consistency.test.js

@@ -0,0 +1,154 @@
+"use strict";
+
+const assert = require("assert");
+const { QueryScanConsistency } = require("couchbase");
+const Database = require("./index");
+
+let passed = 0;
+let failed = 0;
+
+function createQueryDb() {
+  const calls = [];
+  const db = Object.create(Database.prototype);
+  db.query_scope = "cluster";
+  db.cluster = {
+    query: async (statement, options) => {
+      calls.push({ target: "cluster", statement, options });
+      return { rows: [] };
+    },
+  };
+  db.scope = {
+    query: async (statement, options) => {
+      calls.push({ target: "scope", statement, options });
+      return { rows: [] };
+    },
+  };
+  db.optimize = () => {};
+  return { db, calls };
+}
+
+async function test(name, fn) {
+  try {
+    await fn();
+    console.log(`✓ ${name}`);
+    passed += 1;
+  } catch (error) {
+    console.log(`✗ ${name}`);
+    console.log(`  Error: ${error.stack || error.message}`);
+    failed += 1;
+  }
+}
+
+async function run() {
+  console.log("\n--- query consistency tests ---");
+
+  await test("ordinary SQL++ queries default to not_bounded", async () => {
+    const { db, calls } = createQueryDb();
+
+    await db.query("SELECT 1");
+
+    assert.strictEqual(calls[0].target, "cluster");
+    assert.strictEqual(
+      calls[0].options.scanConsistency,
+      QueryScanConsistency.NotBounded,
+    );
+  });
+
+  await test("request_plus can be selected explicitly", async () => {
+    const { db, calls } = createQueryDb();
+
+    await db.query("SELECT 1", "scope", {
+      scan_consistency: "request_plus",
+      scan_wait: 2500,
+    });
+
+    assert.strictEqual(calls[0].target, "scope");
+    assert.strictEqual(
+      calls[0].options.scanConsistency,
+      QueryScanConsistency.RequestPlus,
+    );
+    assert.strictEqual(calls[0].options.scanWait, 2500);
+  });
+
+  await test("legacy boolean consistency values remain supported", async () => {
+    const { db, calls } = createQueryDb();
+
+    await db.query("SELECT 1", "cluster", { scan_consistency: true });
+
+    assert.strictEqual(
+      calls[0].options.scanConsistency,
+      QueryScanConsistency.RequestPlus,
+    );
+  });
+
+  await test("mutation state is forwarded without a conflicting scan mode", async () => {
+    const { db, calls } = createQueryDb();
+    const mutationState = { token: "test-token" };
+
+    await db.query("SELECT 1", {
+      consistent_with: mutationState,
+      scan_wait: 1000,
+    });
+
+    assert.strictEqual(calls[0].options.consistentWith, mutationState);
+    assert.strictEqual(calls[0].options.scanConsistency, undefined);
+    assert.strictEqual(calls[0].options.scanWait, 1000);
+  });
+
+  await test("search keeps query scope separate from consistency", async () => {
+    const db = Object.create(Database.prototype);
+    const calls = [];
+    db.use_bucket_name = true;
+    db.bucket = "documents";
+    db.scope_name = "_default";
+    db.collection_name = "_default";
+    db.getData = async (statement, scope, options) => {
+      calls.push({ kind: "data", statement, scope, options });
+      return [];
+    };
+    db.getCount = async (statement, scope, options) => {
+      calls.push({ kind: "count", statement, scope, options });
+      return 0;
+    };
+    const options = { scan_consistency: "request_plus" };
+
+    await db.search(
+      "application",
+      "",
+      "",
+      10,
+      0,
+      "created_at DESC",
+      "true",
+      "cluster",
+      "",
+      options,
+    );
+
+    assert.deepStrictEqual(
+      calls.map((call) => call.scope),
+      ["cluster", "cluster"],
+    );
+    assert.strictEqual(calls[0].options, options);
+    assert.strictEqual(calls[1].options, options);
+  });
+
+  await test("invalid consistency values fail before issuing a query", async () => {
+    const { db, calls } = createQueryDb();
+
+    await assert.rejects(
+      () => db.query("SELECT 1", "cluster", { scan_consistency: "eventual" }),
+      /Unsupported query scan consistency/,
+    );
+    assert.strictEqual(calls.length, 0);
+  });
+
+  console.log(`\nPassed: ${passed}`);
+  console.log(`Failed: ${failed}`);
+  if (failed > 0) process.exitCode = 1;
+}
+
+run().catch((error) => {
+  console.error(error);
+  process.exit(1);
+});

package/src/utility.js

@@ -293,8 +293,23 @@ function splitSelectClause(clause) {
   return parts;
 }
 
+function hasQualifiedWildcardProjection(query) {
+  const selectMatch = query.match(/\bSELECT\b(.+?)\bFROM\b/is);
+  if (!selectMatch) {
+    return false;
+  }
+
+  return splitSelectClause(selectMatch[1].trim()).some((part) => {
+    const trimmedPart = part.trim();
+    return (
+      /^\(\s*`?\w+`?\s*\)\s*\.\s*\*$/.test(trimmedPart) ||
+      /^`?\w+`?\s*\.\s*\*$/.test(trimmedPart)
+    );
+  });
+}
+
 /**
- * Builds a covering index CREATE statement from a query
+ * Builds a covering or fallback non-covering index CREATE statement from a query
  * @param {string} query - The N1QL query to analyze
  * @param {Object} options - Configuration options
  * @param {string} options.bucket - The bucket name
@@ -303,16 +318,17 @@ function splitSelectClause(clause) {
  * @returns {string|null} - The CREATE INDEX statement, or null if cannot build
  */
 function buildCoveringIndex(query, options) {
-  const { bucket, scope, collection } = options;
+  const { bucket, scope = "_default", collection = "_default" } = options;
 
-  if (!bucket || !scope || !collection) {
+  if (!bucket) {
     return null;
   }
 
   // Extract fields from SELECT clause
   const selectFields = extractSelectFields(query);
-  if (selectFields === null) {
-    // SELECT * query - cannot create covering index
+  const isNonCoveringFallback =
+    selectFields === null && hasQualifiedWildcardProjection(query);
+  if (selectFields === null && !isNonCoveringFallback) {
     return null;
   }
 
@@ -356,7 +372,7 @@ function buildCoveringIndex(query, options) {
   });
 
   // Filter SELECT fields (remove duplicates from WHERE, GROUP BY, and ORDER BY, remove deleted)
-  const selectFieldsFiltered = selectFields.filter((f) => {
+  const selectFieldsFiltered = (selectFields || []).filter((f) => {
     const lower = f.toLowerCase();
     if (addedFields.has(lower) || lower === "deleted") {
       return false;
@@ -393,9 +409,10 @@ function buildCoveringIndex(query, options) {
   const orderFieldsKey = orderByIndexFields
     .map((field) => formatIndexKey(field.name, orderDirectionMap))
     .join(",");
-  const indexKey = `${bucket}|${scope}|${collection}|fields:${indexFieldsKey}|order:${orderFieldsKey}`;
+  const indexMode = isNonCoveringFallback ? "noncovered" : "covered";
+  const indexKey = `${bucket}|${scope}|${collection}|mode:${indexMode}|fields:${indexFieldsKey}|order:${orderFieldsKey}`;
   const hash = generateHash(indexKey);
-  const indexName = `adv_covered_${hash}`;
+  const indexName = `adv_${indexMode}_${hash}`;
 
   // Build the CREATE INDEX statement
   const indexStatement = `CREATE INDEX \`${indexName}\` ON \`default\`:\`${bucket}\`.\`${scope}\`.\`${collection}\`(${fieldList})`;