spice-couchbase 2.0.63 → 2.0.65

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

@@ -1,4 +1,5 @@
 "use strict";
+
 /**
  * Regression tests for the WHERE clause shared by the data and count queries in `search()`.
  *
@@ -9,19 +10,14 @@
  *
  * It survived the existing suite because nothing exercised the count statement.
  */
-
-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); }); }; }
-
+function asyncGeneratorStep(n, t, e, r, o, a, c) { try { var i = n[a](c), u = i.value; } catch (n) { return void e(n); } i.done ? t(u) : Promise.resolve(u).then(r, o); }
+function _asyncToGenerator(n) { return function () { var t = this, e = arguments; return new Promise(function (r, o) { var a = n.apply(t, e); function _next(n) { asyncGeneratorStep(a, r, o, _next, _throw, "next", n); } function _throw(n) { asyncGeneratorStep(a, r, o, _next, _throw, "throw", n); } _next(void 0); }); }; }
 var assert = require("assert");
-
 var Database = require("./index");
-
 var passed = 0;
 var failed = 0;
-/** Captures the two statements `search()` produces without touching a cluster. */
 
+/** Captures the two statements `search()` produces without touching a cluster. */
 function createSearchDb() {
   var statements = {
     data: null,
@@ -32,45 +28,33 @@ function createSearchDb() {
   db.bucket = "test";
   db.scope_name = "scope";
   db.collection_name = "platformtask";
-
-  db.getData =
-  /*#__PURE__*/
-  function () {
+  db.getData = /*#__PURE__*/function () {
     var _ref = _asyncToGenerator(function* (statement) {
       statements.data = statement;
       return [];
     });
-
     return function (_x) {
       return _ref.apply(this, arguments);
     };
   }();
-
-  db.getCount =
-  /*#__PURE__*/
-  function () {
+  db.getCount = /*#__PURE__*/function () {
     var _ref2 = _asyncToGenerator(function* (statement) {
       statements.count = statement;
       return 0;
     });
-
     return function (_x2) {
       return _ref2.apply(this, arguments);
     };
   }();
-
   db.optimize = () => {};
-
   return {
     db,
     statements
   };
 }
-
 function test(_x3, _x4) {
   return _test.apply(this, arguments);
 }
-
 function _test() {
   _test = _asyncToGenerator(function* (name, fn) {
     try {
@@ -85,69 +69,50 @@ function _test() {
   });
   return _test.apply(this, arguments);
 }
-
 function run() {
   return _run.apply(this, arguments);
 }
-
 function _run() {
   _run = _asyncToGenerator(function* () {
     console.log("\n--- count query tests ---");
-    yield test("the count query carries the predicates, not a dangling WHERE",
-    /*#__PURE__*/
-    _asyncToGenerator(function* () {
-      var {
-        db,
-        statements
-      } = createSearchDb();
+    yield test("the count query carries the predicates, not a dangling WHERE", /*#__PURE__*/_asyncToGenerator(function* () {
+      var _createSearchDb = createSearchDb(),
+        db = _createSearchDb.db,
+        statements = _createSearchDb.statements;
       yield db.search("platformtask", "id", "status = \"pending\"", 1, 0, null, "true");
       assert.ok(statements.count.includes("status = \"pending\""), "count query lost its predicate: ".concat(statements.count));
       assert.ok(!/WHERE\s*$/.test(statements.count.trim()), "count query ends in a dangling WHERE: ".concat(statements.count));
     }));
-    yield test("multiple conditions are joined with AND in the count query",
-    /*#__PURE__*/
-    _asyncToGenerator(function* () {
-      var {
-        db,
-        statements
-      } = createSearchDb();
+    yield test("multiple conditions are joined with AND in the count query", /*#__PURE__*/_asyncToGenerator(function* () {
+      var _createSearchDb2 = createSearchDb(),
+        db = _createSearchDb2.db,
+        statements = _createSearchDb2.statements;
       yield db.search("platformtask", "id", "status = \"pending\" AND assignee_type = \"user\"", 1, 0, null, "true");
       assert.ok(statements.count.includes("status = \"pending\""));
       assert.ok(statements.count.includes("assignee_type = \"user\""));
     }));
-    yield test("an unfiltered count emits no WHERE at all",
-    /*#__PURE__*/
-    _asyncToGenerator(function* () {
-      var {
-        db,
-        statements
-      } = createSearchDb();
+    yield test("an unfiltered count emits no WHERE at all", /*#__PURE__*/_asyncToGenerator(function* () {
+      var _createSearchDb3 = createSearchDb(),
+        db = _createSearchDb3.db,
+        statements = _createSearchDb3.statements;
       yield db.search("platformtask", "id", "", 1, 0, null, "true");
       assert.ok(!/WHERE/i.test(statements.count), "unfiltered count should have no WHERE: ".concat(statements.count));
     }));
-    yield test("the data and count queries agree on the WHERE clause",
-    /*#__PURE__*/
-    _asyncToGenerator(function* () {
-      var {
-        db,
-        statements
-      } = createSearchDb();
+    yield test("the data and count queries agree on the WHERE clause", /*#__PURE__*/_asyncToGenerator(function* () {
+      var _createSearchDb4 = createSearchDb(),
+        db = _createSearchDb4.db,
+        statements = _createSearchDb4.statements;
       yield db.search("platformtask", "id", "status = \"blocked\"", 1, 0, null, "true");
-
       var whereOf = sql => {
-        var m = sql.match(/WHERE[\t-\r \xA0\u1680\u2000-\u200A\u2028\u2029\u202F\u205F\u3000\uFEFF]+([\s\S]*?)(?:[\t-\r \xA0\u1680\u2000-\u200A\u2028\u2029\u202F\u205F\u3000\uFEFF]+ORDER BY|[\t-\r \xA0\u1680\u2000-\u200A\u2028\u2029\u202F\u205F\u3000\uFEFF]+LIMIT|[\t-\r \xA0\u1680\u2000-\u200A\u2028\u2029\u202F\u205F\u3000\uFEFF]+OFFSET|$)/i);
+        var m = sql.match(/WHERE\s+([^]*?)(?:\s+ORDER BY|\s+LIMIT|\s+OFFSET|$)/i);
         return m ? m[1].trim() : null;
       };
-
       assert.strictEqual(whereOf(statements.data), whereOf(statements.count));
     }));
-    yield test("no count statement is produced when do_count is off",
-    /*#__PURE__*/
-    _asyncToGenerator(function* () {
-      var {
-        db,
-        statements
-      } = createSearchDb();
+    yield test("no count statement is produced when do_count is off", /*#__PURE__*/_asyncToGenerator(function* () {
+      var _createSearchDb5 = createSearchDb(),
+        db = _createSearchDb5.db,
+        statements = _createSearchDb5.statements;
       yield db.search("platformtask", "id", "status = \"pending\"", 1, 0, null, "false");
       assert.strictEqual(statements.count, null);
       assert.ok(statements.data.includes("status = \"pending\""));
@@ -159,5 +124,4 @@ function _run() {
   });
   return _run.apply(this, arguments);
 }
-
 run();

package/build/index.index-management.test.js

@@ -0,0 +1,283 @@
+"use strict";
+
+function asyncGeneratorStep(n, t, e, r, o, a, c) { try { var i = n[a](c), u = i.value; } catch (n) { return void e(n); } i.done ? t(u) : Promise.resolve(u).then(r, o); }
+function _asyncToGenerator(n) { return function () { var t = this, e = arguments; return new Promise(function (r, o) { var a = n.apply(t, e); function _next(n) { asyncGeneratorStep(a, r, o, _next, _throw, "next", n); } function _throw(n) { asyncGeneratorStep(a, r, o, _next, _throw, "throw", n); } _next(void 0); }); }; }
+var assert = require("node:assert/strict");
+var fs = require("node:fs");
+var path = require("node:path");
+var vm = require("node:vm");
+var _require = require("node:test"),
+  test = _require.test;
+var _require2 = require("./utility"),
+  statementShape = _require2.statementShape,
+  planIndexNames = _require2.planIndexNames,
+  usesManagedIndex = _require2.usesManagedIndex,
+  renderIndexKey = _require2.renderIndexKey,
+  BASE_INDEX = _require2.BASE_INDEX;
+
+// Same isolation as index.auto-optimize.test.js: a fresh module per load, so
+// the seen-set, cooldown and handler never leak between tests.
+function loadDriver(durationMs) {
+  var env = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+  var tick = BigInt(0);
+  var module = {
+    exports: {}
+  };
+  vm.runInNewContext(fs.readFileSync(path.join(__dirname, "index.js"), "utf8"), {
+    require,
+    module,
+    console,
+    process: {
+      env,
+      hrtime: {
+        bigint: () => {
+          var current = tick;
+          tick += BigInt(durationMs) * BigInt(1000000);
+          return current;
+        }
+      }
+    }
+  });
+  return module.exports;
+}
+function recordingCluster() {
+  var rowsFor = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : () => [];
+  var calls = [];
+  return {
+    calls,
+    query(statement, options) {
+      return _asyncToGenerator(function* () {
+        calls.push({
+          statement,
+          options
+        });
+        return {
+          rows: rowsFor(statement),
+          meta: {}
+        };
+      })();
+    }
+  };
+}
+function createDatabase(Database, cluster) {
+  var db = Object.create(Database.prototype);
+  db.bucket = "saturn";
+  db.scope_name = "test";
+  db.collection_name = "users";
+  db.db_config = {
+    bucket: "saturn"
+  };
+  db.auto_optimize = true;
+  db.cluster = cluster;
+  db.scope = cluster;
+  return db;
+}
+var KEYSPACE = "default:`saturn`.`test`.`users`";
+test("statement shapes ignore literal values and IN list lengths", () => {
+  assert.equal(statementShape("SELECT * FROM `users` WHERE email = 'a@b.c' AND age > 30 AND id IN ['x', 'y']"), statementShape("SELECT * FROM `users` WHERE email = \"d@e.f\" AND age > 7 AND id IN ['z']"));
+});
+test("managed indexes are recognised in a plan, the base fallback is not", () => {
+  var plan = index => ({
+    "#operator": "Sequence",
+    "~children": [{
+      "#operator": "IndexScan3",
+      index
+    }]
+  });
+  assert.deepEqual(planIndexNames(plan("ix_sort_1a2b3c_9f0e")), ["ix_sort_1a2b3c_9f0e"]);
+  assert.equal(usesManagedIndex(plan("ix_sort_1a2b3c_9f0e")), true);
+  assert.equal(usesManagedIndex(plan("ix_base")), false);
+  assert.equal(usesManagedIndex(plan("adv_covered_1a3952f8")), false);
+});
+test("index keys render direction and INCLUDE MISSING", () => {
+  assert.deepEqual(BASE_INDEX.keys.map(renderIndexKey), ["`created_at` DESC INCLUDE MISSING", "`deleted`"]);
+  assert.equal(renderIndexKey("`name`"), "`name`");
+  assert.throws(() => renderIndexKey({}), TypeError);
+});
+test("createIndex is idempotent, deferred by default and fully qualified", /*#__PURE__*/_asyncToGenerator(function* () {
+  var cluster = recordingCluster();
+  var db = createDatabase(loadDriver(0), cluster);
+  yield db.createIndex({
+    name: "ix_sort_1a2b3c_9f0e",
+    keys: [{
+      expr: "`priority`",
+      desc: true,
+      include_missing: true
+    }, {
+      expr: "IFMISSINGORNULL(`due_at`, {})"
+    }],
+    where: "IFMISSING(`deleted`, false) = false",
+    num_replica: 1
+  });
+  assert.equal(cluster.calls[0].statement, "CREATE INDEX IF NOT EXISTS `ix_sort_1a2b3c_9f0e` ON ".concat(KEYSPACE) + "(`priority` DESC INCLUDE MISSING, IFMISSINGORNULL(`due_at`, {})) " + 'WHERE IFMISSING(`deleted`, false) = false WITH {"defer_build":true,"num_replica":1}');
+}));
+test("build, drop and primary drop target the collection", /*#__PURE__*/_asyncToGenerator(function* () {
+  var cluster = recordingCluster();
+  var db = createDatabase(loadDriver(0), cluster);
+  yield db.buildIndexes(["ix_a", "ix_b", "ix_a"]);
+  yield db.dropIndex("ix_a");
+  yield db.dropPrimaryIndex();
+  assert.deepEqual(cluster.calls.map(_ref3 => {
+    var statement = _ref3.statement;
+    return statement;
+  }), ["BUILD INDEX ON ".concat(KEYSPACE, "(`ix_a`, `ix_b`)"), "DROP INDEX IF EXISTS `ix_a` ON ".concat(KEYSPACE), "DROP PRIMARY INDEX IF EXISTS ON ".concat(KEYSPACE)]);
+  assert.equal(yield db.buildIndexes([]), null);
+}));
+test("a partial index inventory is an error, not an empty list", /*#__PURE__*/_asyncToGenerator(function* () {
+  var Database = loadDriver(0);
+  var db = createDatabase(Database, {
+    query() {
+      return _asyncToGenerator(function* () {
+        return {
+          rows: [],
+          meta: {
+            warnings: [{
+              msg: "partial"
+            }]
+          }
+        };
+      })();
+    }
+  });
+  yield assert.rejects(() => db.listIndexes(), /index inventory/);
+}));
+test("the client context id reaches the SDK options", /*#__PURE__*/_asyncToGenerator(function* () {
+  var cluster = recordingCluster();
+  var db = createDatabase(loadDriver(0), cluster);
+  yield db.query("SELECT 1", "cluster", {
+    client_context_id: "scheduler.due"
+  });
+  assert.equal(cluster.calls[0].options.clientContextId, "scheduler.due");
+}));
+function scanTimeout() {
+  var error = new Error("Index scan timed out");
+  error.cause = {
+    first_error_code: 12015,
+    first_error_message: "Index scan timed out"
+  };
+  return error;
+}
+test("an expired scan_wait reruns without waiting only when the caller allows it", /*#__PURE__*/_asyncToGenerator(function* () {
+  var Database = loadDriver(0);
+  var attempts = [];
+  var cluster = {
+    query(statement, options) {
+      return _asyncToGenerator(function* () {
+        attempts.push(options);
+        if (attempts.length === 1) throw scanTimeout();
+        return {
+          rows: [{
+            ok: true
+          }]
+        };
+      })();
+    }
+  };
+  var db = createDatabase(Database, cluster);
+  var response = yield db.query("SELECT 1", "cluster", {
+    scan_consistency: "request_plus",
+    scan_wait: 2000,
+    scan_wait_fallback: true
+  });
+  assert.deepEqual(response.rows, [{
+    ok: true
+  }]);
+  assert.equal(attempts.length, 2);
+  assert.equal(attempts[1].scanWait, undefined);
+  assert.notEqual(attempts[1].scanConsistency, attempts[0].scanConsistency);
+}));
+test("without the fallback an expired scan_wait is an error", /*#__PURE__*/_asyncToGenerator(function* () {
+  var Database = loadDriver(0);
+  var db = createDatabase(Database, {
+    query() {
+      return _asyncToGenerator(function* () {
+        throw scanTimeout();
+      })();
+    }
+  });
+  yield assert.rejects(() => db.query("SELECT 1", "cluster", {
+    scan_consistency: "request_plus",
+    scan_wait: 2000
+  }), /Index scan timed out/);
+}));
+test("with a handler installed, slow statements are handed off once per shape and never indexed here", /*#__PURE__*/_asyncToGenerator(function* () {
+  var Database = loadDriver(5000);
+  var cluster = recordingCluster(statement => statement.startsWith("EXPLAIN ") ? [{
+    "#operator": "IndexScan3",
+    index: "ix_base"
+  }] : []);
+  var db = createDatabase(Database, cluster);
+  var reports = [];
+  Database.setSlowStatementHandler(/*#__PURE__*/function () {
+    var _ref9 = _asyncToGenerator(function* (report) {
+      return reports.push(report);
+    });
+    return function (_x) {
+      return _ref9.apply(this, arguments);
+    };
+  }());
+  var legacy = 0;
+  db.optimize = /*#__PURE__*/_asyncToGenerator(function* () {
+    legacy += 1;
+  });
+  yield db.query("SELECT name FROM users WHERE email = 'a@b.c'");
+  yield db.query("SELECT name FROM users WHERE email = 'd@e.f'");
+  yield new Promise(resolve => setImmediate(resolve));
+  assert.equal(reports.length, 1);
+  assert.equal(reports[0].shape, "SELECT name FROM users WHERE email = ?");
+  assert.equal(reports[0].collection, "users");
+  assert.equal(legacy, 0);
+  assert.equal(cluster.calls.some(_ref1 => {
+    var statement = _ref1.statement;
+    return statement.startsWith("CREATE ");
+  }), false);
+}));
+test("a slow statement already served by a managed index is not reported", /*#__PURE__*/_asyncToGenerator(function* () {
+  var Database = loadDriver(5000);
+  var cluster = recordingCluster(statement => statement.startsWith("EXPLAIN ") ? [{
+    "#operator": "IndexScan3",
+    index: "ix_sort_1a2b3c_9f0e"
+  }] : []);
+  var db = createDatabase(Database, cluster);
+  var reports = [];
+  Database.setSlowStatementHandler(/*#__PURE__*/function () {
+    var _ref11 = _asyncToGenerator(function* (report) {
+      return reports.push(report);
+    });
+    return function (_x2) {
+      return _ref11.apply(this, arguments);
+    };
+  }());
+  yield db.query("SELECT name FROM users ORDER BY priority DESC");
+  yield new Promise(resolve => setImmediate(resolve));
+  assert.equal(reports.length, 0);
+}));
+test("without a handler the legacy covering-index path still runs", /*#__PURE__*/_asyncToGenerator(function* () {
+  var Database = loadDriver(5000);
+  var db = createDatabase(Database, recordingCluster());
+  var legacy = 0;
+  db.optimize = /*#__PURE__*/_asyncToGenerator(function* () {
+    legacy += 1;
+  });
+  yield db.query("SELECT name FROM users WHERE status = 'active'");
+  assert.equal(legacy, 1);
+}));
+test("a new collection gets the base index instead of a primary index when asked", /*#__PURE__*/_asyncToGenerator(function* () {
+  var Database = loadDriver(0);
+  var cluster = recordingCluster();
+  var db = createDatabase(Database, cluster);
+  db.db_config.primary_index = false;
+  db.checkGlobelConnectionObject = () => false;
+  db.collectionExists = /*#__PURE__*/_asyncToGenerator(function* () {
+    return false;
+  });
+  db.createCollection = /*#__PURE__*/_asyncToGenerator(function* () {});
+  db.wait = /*#__PURE__*/_asyncToGenerator(function* () {});
+  var primary = 0;
+  db.createPrimaryIndex = /*#__PURE__*/_asyncToGenerator(function* () {
+    primary += 1;
+  });
+  yield db.upsertCollection();
+  assert.equal(primary, 0);
+  assert.match(cluster.calls[0].statement, /^CREATE INDEX IF NOT EXISTS `ix_base` ON .*\(`created_at` DESC INCLUDE MISSING, `deleted`\) WITH \{"defer_build":false\}$/);
+}));