spice-couchbase 2.0.61 → 2.0.63

package/build/index.auto-optimize.test.js

@@ -94,9 +94,10 @@ function createStatements(scope) {
     return statement.startsWith("CREATE INDEX ");
   });
 } // Isolate optimizer state and time without connecting to Couchbase or sleeping.
+// Each load is a fresh module: its own seen-set, cooldown and policy.
 
 
-function createDatabase(durationMs) {
+function loadDriver(durationMs) {
   var env = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
   var tick = BigInt(0);
   var module = {
@@ -117,7 +118,11 @@ function createDatabase(durationMs) {
       }
     }
   });
-  var db = Object.create(module.exports.prototype);
+  return module.exports;
+}
+
+function instanceOf(Database) {
+  var db = Object.create(Database.prototype);
   db.bucket = "saturn";
   db.scope_name = "test";
   db.collection_name = "users";
@@ -137,6 +142,14 @@ function createDatabase(durationMs) {
     }()
   };
   return db;
+} // Opted in wholesale: per-resource resolution has its own tests further down.
+
+
+function createDatabase(durationMs) {
+  var env = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+  var db = instanceOf(loadDriver(durationMs, env));
+  db.auto_optimize = true;
+  return db;
 }
 
 test("auto-optimization only starts above the default 3-second threshold",
@@ -373,4 +386,193 @@ _asyncToGenerator(function* () {
     collection: "_default"
   }));
   assert.match(createStatements(scope)[0].statement, /`saturn`\.`_default`\.`_default`/);
+})); // ---- Per-resource opt-in for auto cover indexing ----
+// Nothing decided at instance level: resolution falls through to the call,
+// the application policy and the static lists.
+
+function createUnconfiguredDatabase() {
+  var env = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+  return instanceOf(loadDriver(3001, env));
+}
+
+function optimizationsFor(_x2, _x3) {
+  return _optimizationsFor.apply(this, arguments);
+}
+
+function _optimizationsFor() {
+  _optimizationsFor = _asyncToGenerator(function* (db, statement) {
+    var optimizations = 0;
+    db.optimize =
+    /*#__PURE__*/
+    _asyncToGenerator(function* () {
+      optimizations += 1;
+    });
+
+    for (var _len = arguments.length, queryArgs = new Array(_len > 2 ? _len - 2 : 0), _key = 2; _key < _len; _key++) {
+      queryArgs[_key - 2] = arguments[_key];
+    }
+
+    yield db.query(statement, ...queryArgs);
+    return optimizations;
+  });
+  return _optimizationsFor.apply(this, arguments);
+}
+
+var slowLookup = "SELECT name FROM users WHERE status = 'active'";
+var EVERY_RESOURCE = {
+  SPICE_COUCHBASE_OPTIMIZE_RESOURCES: "*"
+};
+test("no resource is auto-indexed unless something opts it in",
+/*#__PURE__*/
+_asyncToGenerator(function* () {
+  assert.equal((yield optimizationsFor(createUnconfiguredDatabase(), slowLookup)), 0);
+  assert.equal((yield optimizationsFor(createUnconfiguredDatabase({
+    SPICE_COUCHBASE_OPTIMIZE_RESOURCES: ""
+  }), slowLookup)), 0);
+}));
+test("SPICE_COUCHBASE_OPTIMIZE_RESOURCES enables the instance's collection, case-insensitively",
+/*#__PURE__*/
+_asyncToGenerator(function* () {
+  var env = {
+    SPICE_COUCHBASE_OPTIMIZE_RESOURCES: " Users ,audit_log,, `sessions` "
+  };
+  assert.equal((yield optimizationsFor(createUnconfiguredDatabase(env), slowLookup)), 1);
+  var sessions = createUnconfiguredDatabase(env);
+  sessions.collection_name = "sessions";
+  assert.equal((yield optimizationsFor(sessions, "SELECT id FROM sessions")), 1);
+  var orders = createUnconfiguredDatabase(env);
+  orders.collection_name = "orders";
+  assert.equal((yield optimizationsFor(orders, "SELECT total FROM orders WHERE status = 'paid'")), 0);
+}));
+test("a wildcard restores auto indexing for every resource",
+/*#__PURE__*/
+_asyncToGenerator(function* () {
+  var db = createUnconfiguredDatabase(EVERY_RESOURCE);
+  db.collection_name = "anything";
+  assert.equal((yield optimizationsFor(db, "SELECT a FROM anything WHERE b = 1")), 1);
+}));
+test("legacy bucket mode resolves the resource from the type literal the driver adds",
+/*#__PURE__*/
+_asyncToGenerator(function* () {
+  var env = {
+    SPICE_COUCHBASE_OPTIMIZE_RESOURCES: "audit_log"
+  };
+
+  for (var [type, expected] of [["audit_log", 1], ["users", 0]]) {
+    var db = createUnconfiguredDatabase(env);
+    db.collection_name = "_default";
+    db.scope_name = "_default";
+    assert.equal((yield optimizationsFor(db, "SELECT actor FROM `saturn` WHERE type = '".concat(type, "' AND deleted = false"))), expected, type);
+  }
+}));
+test("a fully qualified or aliased FROM keyspace matches on its last segment",
+/*#__PURE__*/
+_asyncToGenerator(function* () {
+  var env = {
+    SPICE_COUCHBASE_OPTIMIZE_RESOURCES: "logs"
+  };
+
+  for (var statement of ["SELECT level FROM `default`:`saturn`.`app`.`logs` WHERE level = 'error'", "SELECT l.level FROM saturn.app.logs AS l WHERE l.level = 'error'", "SELECT u.name FROM users AS u JOIN `logs` AS l ON l.user_id = META(u).id"]) {
+    var db = createUnconfiguredDatabase(env);
+    db.collection_name = "_default";
+    assert.equal((yield optimizationsFor(db, statement)), 1, statement);
+  }
+}));
+test("connection or constructor lists work without the environment variable",
+/*#__PURE__*/
+_asyncToGenerator(function* () {
+  var db = createUnconfiguredDatabase();
+  db.enabled_resources = new Set(["users"]);
+  assert.equal((yield optimizationsFor(db, slowLookup)), 1);
+}));
+test("an explicit instance setting overrides every resource list",
+/*#__PURE__*/
+_asyncToGenerator(function* () {
+  var on = createUnconfiguredDatabase();
+  on.auto_optimize = true;
+  assert.equal((yield optimizationsFor(on, slowLookup)), 1);
+  var off = createUnconfiguredDatabase(EVERY_RESOURCE);
+  off.auto_optimize = false;
+  assert.equal((yield optimizationsFor(off, slowLookup)), 0);
+}));
+test("a single call can opt in or out through query options",
+/*#__PURE__*/
+_asyncToGenerator(function* () {
+  assert.equal((yield optimizationsFor(createUnconfiguredDatabase(), slowLookup, {
+    auto_optimize: true
+  })), 1);
+  assert.equal((yield optimizationsFor(createUnconfiguredDatabase(EVERY_RESOURCE), slowLookup, {
+    auto_optimize: false
+  })), 0);
+  assert.equal((yield optimizationsFor(createUnconfiguredDatabase(EVERY_RESOURCE), slowLookup, "cluster", {
+    optimize: false
+  })), 0); // The scan-consistency shorthand is not an opt-in or opt-out.
+
+  assert.equal((yield optimizationsFor(createUnconfiguredDatabase(EVERY_RESOURCE), slowLookup, "cluster", true)), 1);
+  assert.equal((yield optimizationsFor(createUnconfiguredDatabase(), slowLookup, "cluster", true)), 0);
+}));
+test("an application policy decides per resource and sees the statement context",
+/*#__PURE__*/
+_asyncToGenerator(function* () {
+  var Database = loadDriver(3001);
+  var seen = [];
+  Database.setAutoOptimizePolicy((resource, context) => {
+    seen.push([resource, context]);
+    return resource === "users";
+  });
+  assert.equal(Database.getAutoOptimizePolicy().length, 2);
+  var users = instanceOf(Database);
+  users.connection_name = "default";
+  assert.equal((yield optimizationsFor(users, slowLookup)), 1); // Objects cross the vm boundary, so compare by value rather than prototype.
+
+  assert.equal(JSON.stringify(seen[0]), JSON.stringify(["users", {
+    query: slowLookup,
+    connection: "default",
+    collection: "users"
+  }]));
+  var orders = instanceOf(Database);
+  orders.collection_name = "orders";
+  assert.equal((yield optimizationsFor(orders, "SELECT total FROM orders WHERE status = 'paid'")), 0);
+}));
+test("a policy that returns undefined defers to the static lists",
+/*#__PURE__*/
+_asyncToGenerator(function* () {
+  for (var [env, expected] of [[{
+    SPICE_COUCHBASE_OPTIMIZE_RESOURCES: "users"
+  }, 1], [{}, 0]]) {
+    var Database = loadDriver(3001, env);
+    Database.setAutoOptimizePolicy(() => undefined);
+    assert.equal((yield optimizationsFor(instanceOf(Database), slowLookup)), expected);
+  }
+}));
+test("an explicit policy refusal wins over the wildcard, and a throwing policy counts as a refusal",
+/*#__PURE__*/
+_asyncToGenerator(function* () {
+  for (var policy of [() => false, () => {
+    throw new Error("settings unavailable");
+  }]) {
+    var Database = loadDriver(3001, EVERY_RESOURCE);
+    Database.setAutoOptimizePolicy(policy);
+    assert.equal((yield optimizationsFor(instanceOf(Database), slowLookup)), 0);
+  }
+}));
+test("the policy can be cleared and must be a function",
+/*#__PURE__*/
+_asyncToGenerator(function* () {
+  var Database = loadDriver(3001, EVERY_RESOURCE);
+  Database.setAutoOptimizePolicy(() => false);
+  Database.setAutoOptimizePolicy(null);
+  assert.equal(Database.getAutoOptimizePolicy(), null);
+  assert.equal((yield optimizationsFor(instanceOf(Database), slowLookup)), 1);
+  assert.throws(() => Database.setAutoOptimizePolicy("users"), {
+    name: "TypeError"
+  });
+}));
+test("a declined statement is not remembered as already optimised",
+/*#__PURE__*/
+_asyncToGenerator(function* () {
+  var db = createUnconfiguredDatabase();
+  assert.equal((yield optimizationsFor(db, slowLookup)), 0);
+  db.auto_optimize = true;
+  assert.equal((yield optimizationsFor(db, slowLookup)), 1);
 }));