spice-couchbase 2.0.54 → 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 {
@@ -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,9 +919,7 @@ 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

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/package.json

@@ -1,10 +1,11 @@
 {
   "name": "spice-couchbase",
-  "version": "2.0.54",
+  "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,
@@ -557,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";
@@ -628,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);
 
@@ -698,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;
   }
 
@@ -772,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;
 
@@ -784,9 +860,7 @@ 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();

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);
+});