spice-couchbase 2.0.64 → 2.0.65

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

@@ -1,39 +1,33 @@
 "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); }); }; }
-
-function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); keys.push.apply(keys, symbols); } return keys; }
-
-function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
-
-function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
-
+function _slicedToArray(r, e) { return _arrayWithHoles(r) || _iterableToArrayLimit(r, e) || _unsupportedIterableToArray(r, e) || _nonIterableRest(); }
+function _nonIterableRest() { throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
+function _unsupportedIterableToArray(r, a) { if (r) { if ("string" == typeof r) return _arrayLikeToArray(r, a); var t = {}.toString.call(r).slice(8, -1); return "Object" === t && r.constructor && (t = r.constructor.name), "Map" === t || "Set" === t ? Array.from(r) : "Arguments" === t || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t) ? _arrayLikeToArray(r, a) : void 0; } }
+function _arrayLikeToArray(r, a) { (null == a || a > r.length) && (a = r.length); for (var e = 0, n = Array(a); e < a; e++) n[e] = r[e]; return n; }
+function _iterableToArrayLimit(r, l) { var t = null == r ? null : "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"]; if (null != t) { var e, n, i, u, a = [], f = !0, o = !1; try { if (i = (t = t.call(r)).next, 0 === l) { if (Object(t) !== t) return; f = !1; } else for (; !(f = (e = i.call(t)).done) && (a.push(e.value), a.length !== l); f = !0); } catch (r) { o = !0, n = r; } finally { try { if (!f && null != t.return && (u = t.return(), Object(u) !== u)) return; } finally { if (o) throw n; } } return a; } }
+function _arrayWithHoles(r) { if (Array.isArray(r)) return r; }
+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); }); }; }
+function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
+function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
+function _defineProperty(e, r, t) { return (r = _toPropertyKey(r)) in e ? Object.defineProperty(e, r, { value: t, enumerable: !0, configurable: !0, writable: !0 }) : e[r] = t, e; }
+function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == typeof i ? i : i + ""; }
+function _toPrimitive(t, e) { if ("object" != typeof t || !t) return t; var r; if ("undefined" != typeof Symbol && void 0 !== (r = t[Symbol.toPrimitive])) { var i = r.call(t, e || "default"); if ("object" != typeof i) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === e ? String : Number)(t); }
 var assert = require("node:assert/strict");
-
 var fs = require("node:fs");
-
 var path = require("node:path");
-
 var vm = require("node:vm");
-
-var {
-  test
-} = require("node:test");
-
-var {
-  buildCoveringIndex,
-  buildCoveringIndexDefinition
-} = require("./utility");
-
+var _require = require("node:test"),
+  test = _require.test;
+var _require2 = require("./utility"),
+  buildCoveringIndex = _require2.buildCoveringIndex,
+  buildCoveringIndexDefinition = _require2.buildCoveringIndexDefinition;
 var keyspace = {
   bucket: "saturn",
   scope: "test",
   collection: "users"
 };
 var lookupQuery = "SELECT name, email FROM users WHERE status = 'active'";
-
 function existingIndex(index_key) {
   var overrides = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
   return _objectSpread({
@@ -43,25 +37,21 @@ function existingIndex(index_key) {
     index_key
   }, overrides);
 }
-
 function executionScope() {
   var indexes = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : [];
-  var {
-    inventoryError,
-    inventoryResponse,
-    plan
-  } = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+  var _ref = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {},
+    inventoryError = _ref.inventoryError,
+    inventoryResponse = _ref.inventoryResponse,
+    plan = _ref.plan;
   var calls = [];
   return {
     calls,
-
     query(statement, options) {
       return _asyncToGenerator(function* () {
         calls.push({
           statement,
           options
         });
-
         if (statement.startsWith("EXPLAIN ")) {
           return {
             rows: [plan || {
@@ -69,34 +59,28 @@ function executionScope() {
             }]
           };
         }
-
         if (statement.includes("FROM system:indexes")) {
           if (inventoryError) throw inventoryError;
           return inventoryResponse === undefined ? {
             rows: indexes
           } : inventoryResponse;
         }
-
         return {
           rows: []
         };
       })();
     }
-
   };
 }
-
 function createStatements(scope) {
-  return scope.calls.filter((_ref) => {
-    var {
-      statement
-    } = _ref;
+  return scope.calls.filter(_ref2 => {
+    var statement = _ref2.statement;
     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.
-
+}
 
+// 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 loadDriver(durationMs) {
   var env = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
   var tick = BigInt(0);
@@ -120,7 +104,6 @@ function loadDriver(durationMs) {
   });
   return module.exports;
 }
-
 function instanceOf(Database) {
   var db = Object.create(Database.prototype);
   db.bucket = "saturn";
@@ -133,59 +116,49 @@ function instanceOf(Database) {
           rows: []
         };
       });
-
       function query() {
         return _query.apply(this, arguments);
       }
-
       return query;
     }()
   };
   return db;
-} // Opted in wholesale: per-resource resolution has its own tests further down.
-
+}
 
+// 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",
-/*#__PURE__*/
-_asyncToGenerator(function* () {
-  for (var duration of [1001, 2999, 3000, 3001]) {
+test("auto-optimization only starts above the default 3-second threshold", /*#__PURE__*/_asyncToGenerator(function* () {
+  var _loop = function* _loop() {
     var db = createDatabase(duration);
     var optimizations = 0;
-    db.optimize =
-    /*#__PURE__*/
-    _asyncToGenerator(function* () {
+    db.optimize = /*#__PURE__*/_asyncToGenerator(function* () {
       optimizations += 1;
     });
     yield db.query("SELECT name FROM users WHERE status = 'active'");
     assert.equal(optimizations, duration > 3000 ? 1 : 0, "".concat(duration, "ms"));
+  };
+  for (var duration of [1001, 2999, 3000, 3001]) {
+    yield* _loop();
   }
 }));
-test("the explicit slow-query threshold override remains supported",
-/*#__PURE__*/
-_asyncToGenerator(function* () {
+test("the explicit slow-query threshold override remains supported", /*#__PURE__*/_asyncToGenerator(function* () {
   var db = createDatabase(5001, {
     SPICE_COUCHBASE_SLOW_QUERY_MS: "5000"
   });
   var optimizations = 0;
-  db.optimize =
-  /*#__PURE__*/
-  _asyncToGenerator(function* () {
+  db.optimize = /*#__PURE__*/_asyncToGenerator(function* () {
     optimizations += 1;
   });
   yield db.query("SELECT name FROM users WHERE status = 'active'");
   assert.equal(optimizations, 1);
 }));
-test("Fetch plans for full-document projections never create indexes",
-/*#__PURE__*/
-_asyncToGenerator(function* () {
-  var _loop = function* _loop(projection) {
+test("Fetch plans for full-document projections never create indexes", /*#__PURE__*/_asyncToGenerator(function* () {
+  var _loop2 = function* _loop2() {
     var db = createDatabase(0);
     var statements = [];
     var query = "SELECT ".concat(projection, " FROM users WHERE status = 'active' ORDER BY created_at DESC");
@@ -199,24 +172,19 @@ _asyncToGenerator(function* () {
             }]
           };
         });
-
         function query(_x) {
           return _query2.apply(this, arguments);
         }
-
         return query;
       }()
     });
     assert.deepEqual(statements, ["EXPLAIN ".concat(query)]);
   };
-
   for (var projection of ["*", "users.*", "`users`.*", "(`users`).*, META(`users`).id AS id"]) {
-    yield* _loop(projection);
+    yield* _loop2();
   }
 }));
-test("Fetch plans for explicit fields still create a covering index",
-/*#__PURE__*/
-_asyncToGenerator(function* () {
+test("Fetch plans for explicit fields still create a covering index", /*#__PURE__*/_asyncToGenerator(function* () {
   var db = createDatabase(0);
   var scope = executionScope();
   yield db.optimize("SELECT name FROM users WHERE status = 'active'", scope);
@@ -252,11 +220,8 @@ test("case-distinct document fields are not collapsed", () => {
   assert.match(statement, /`status`/);
   assert.doesNotMatch(statement, /`name` DESC/);
 });
-
-var _loop2 = function _loop2(state) {
-  test("an existing ".concat(state, " index with reordered projection keys prevents creation"),
-  /*#__PURE__*/
-  _asyncToGenerator(function* () {
+var _loop3 = function _loop3(state) {
+  test("an existing ".concat(state, " index with reordered projection keys prevents creation"), /*#__PURE__*/_asyncToGenerator(function* () {
     var scope = executionScope([existingIndex(["`deleted` INCLUDE MISSING", "`status`", "`name`", "`email`"], {
       state
     })]);
@@ -265,21 +230,15 @@ var _loop2 = function _loop2(state) {
     assert.equal(createStatements(scope).length, 0);
   }));
 };
-
 for (var state of ["online", "deferred", "pending", "building", "offline"]) {
-  _loop2(state);
+  _loop3(state);
 }
-
-test("a wider existing index covers a projection subset without another index",
-/*#__PURE__*/
-_asyncToGenerator(function* () {
+test("a wider existing index covers a projection subset without another index", /*#__PURE__*/_asyncToGenerator(function* () {
   var scope = executionScope([existingIndex(["`deleted` INCLUDE MISSING", "`status`", "`name`", "`phone`", "`email` DESC"])]);
   yield createDatabase(0).optimize(lookupQuery, scope);
   assert.equal(createStatements(scope).length, 0);
 }));
-test("catalog key formatting, explicit ASC and attribute order are normalized",
-/*#__PURE__*/
-_asyncToGenerator(function* () {
+test("catalog key formatting, explicit ASC and attribute order are normalized", /*#__PURE__*/_asyncToGenerator(function* () {
   for (var leadingKey of ["((`deleted`)) ASC INCLUDE MISSING", "deleted INCLUDE MISSING ASC"]) {
     var scope = executionScope([existingIndex([leadingKey, "(status) ASC", "`name`", "email ASC"])]);
     yield createDatabase(0).optimize(lookupQuery, scope);
@@ -291,33 +250,28 @@ var incompatibleIndexes = [["missing a projection field", existingIndex(["`delet
 })], ["primary index", existingIndex([], {
   is_primary: true
 })]];
-
-var _loop3 = function _loop3(reason, index) {
-  test("does not mistake ".concat(reason, " for a compatible covering index"),
-  /*#__PURE__*/
-  _asyncToGenerator(function* () {
-    var scope = executionScope([index]);
-    yield createDatabase(0).optimize(lookupQuery, scope);
-    assert.equal(createStatements(scope).length, 1);
-  }));
-};
-
-for (var [reason, index] of incompatibleIndexes) {
-  _loop3(reason, index);
+var _loop4 = function _loop4() {
+    _ref10 = _slicedToArray(_ref11, 2);
+    var reason = _ref10[0];
+    var index = _ref10[1];
+    test("does not mistake ".concat(reason, " for a compatible covering index"), /*#__PURE__*/_asyncToGenerator(function* () {
+      var scope = executionScope([index]);
+      yield createDatabase(0).optimize(lookupQuery, scope);
+      assert.equal(createStatements(scope).length, 1);
+    }));
+  },
+  _ref10;
+for (var _ref11 of incompatibleIndexes) {
+  _loop4();
 }
-
-test("existing opposite sort direction does not satisfy the requested sort",
-/*#__PURE__*/
-_asyncToGenerator(function* () {
+test("existing opposite sort direction does not satisfy the requested sort", /*#__PURE__*/_asyncToGenerator(function* () {
   var query = "".concat(lookupQuery, " ORDER BY created_at DESC");
   var scope = executionScope([existingIndex(["`deleted` INCLUDE MISSING", "`status`", "`created_at`", "`name`", "`email`"])]);
   yield createDatabase(0).optimize(query, scope);
   assert.equal(createStatements(scope).length, 1);
   assert.match(createStatements(scope)[0].statement, /`created_at` DESC/);
 }));
-test("same generated name is never recreated even if its keys are unavailable",
-/*#__PURE__*/
-_asyncToGenerator(function* () {
+test("same generated name is never recreated even if its keys are unavailable", /*#__PURE__*/_asyncToGenerator(function* () {
   var candidate = buildCoveringIndexDefinition(lookupQuery, keyspace);
   var scope = executionScope([{
     name: candidate.name,
@@ -326,24 +280,19 @@ _asyncToGenerator(function* () {
   yield createDatabase(0).optimize(lookupQuery, scope);
   assert.equal(createStatements(scope).length, 0);
 }));
-test("catalog failure or incomplete results prevent creation and trigger cooldown",
-/*#__PURE__*/
-_asyncToGenerator(function* () {
-  var _loop4 = function* _loop4(options) {
+test("catalog failure or incomplete results prevent creation and trigger cooldown", /*#__PURE__*/_asyncToGenerator(function* () {
+  var _loop5 = function* _loop5() {
     var db = createDatabase(3001);
     var scope = executionScope([], options);
     yield db.optimize(lookupQuery, scope);
     assert.equal(createStatements(scope).length, 0);
     var retries = 0;
-    db.optimize =
-    /*#__PURE__*/
-    _asyncToGenerator(function* () {
+    db.optimize = /*#__PURE__*/_asyncToGenerator(function* () {
       retries++;
     });
     yield db.query("SELECT email FROM users WHERE status = 'pending'");
     assert.equal(retries, 0);
   };
-
   for (var options of [{
     inventoryError: new Error("query service unavailable")
   }, {
@@ -358,12 +307,10 @@ _asyncToGenerator(function* () {
       }
     }
   }]) {
-    yield* _loop4(options);
+    yield* _loop5();
   }
 }));
-test("already-covered plans need neither an inventory lookup nor creation",
-/*#__PURE__*/
-_asyncToGenerator(function* () {
+test("already-covered plans need neither an inventory lookup nor creation", /*#__PURE__*/_asyncToGenerator(function* () {
   var scope = executionScope([], {
     plan: {
       "#operator": "IndexScan3"
@@ -372,9 +319,7 @@ _asyncToGenerator(function* () {
   yield createDatabase(0).optimize(lookupQuery, scope);
   assert.equal(scope.calls.length, 1);
 }));
-test("a default collection uses default names in its inventory lookup",
-/*#__PURE__*/
-_asyncToGenerator(function* () {
+test("a default collection uses default names in its inventory lookup", /*#__PURE__*/_asyncToGenerator(function* () {
   var db = createDatabase(0);
   db.scope_name = undefined;
   db.collection_name = undefined;
@@ -386,134 +331,112 @@ _asyncToGenerator(function* () {
     collection: "_default"
   }));
   assert.match(createStatements(scope)[0].statement, /`saturn`\.`_default`\.`_default`/);
-})); // ---- Per-resource opt-in for auto cover indexing ----
+}));
+
+// ---- 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* () {
+    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({
+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);
+  }), slowLookup), 0);
 }));
-test("SPICE_COUCHBASE_OPTIMIZE_RESOURCES enables the instance's collection, case-insensitively",
-/*#__PURE__*/
-_asyncToGenerator(function* () {
+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);
+  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);
+  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);
+  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* () {
+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);
+  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* () {
+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]]) {
+  for (var _ref24 of [["audit_log", 1], ["users", 0]]) {
+    var _ref23 = _slicedToArray(_ref24, 2);
+    var type = _ref23[0];
+    var expected = _ref23[1];
     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);
+    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* () {
+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);
+    assert.equal(yield optimizationsFor(db, statement), 1, statement);
   }
 }));
-test("connection or constructor lists work without the environment variable",
-/*#__PURE__*/
-_asyncToGenerator(function* () {
+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);
+  assert.equal(yield optimizationsFor(db, slowLookup), 1);
 }));
-test("an explicit instance setting overrides every resource list",
-/*#__PURE__*/
-_asyncToGenerator(function* () {
+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);
+  assert.equal(yield optimizationsFor(on, slowLookup), 1);
   var off = createUnconfiguredDatabase(EVERY_RESOURCE);
   off.auto_optimize = false;
-  assert.equal((yield optimizationsFor(off, slowLookup)), 0);
+  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, {
+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, {
+  }), 1);
+  assert.equal(yield optimizationsFor(createUnconfiguredDatabase(EVERY_RESOURCE), slowLookup, {
     auto_optimize: false
-  })), 0);
-  assert.equal((yield optimizationsFor(createUnconfiguredDatabase(EVERY_RESOURCE), slowLookup, "cluster", {
+  }), 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);
+  }), 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* () {
+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) => {
@@ -523,8 +446,8 @@ _asyncToGenerator(function* () {
   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(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",
@@ -532,47 +455,42 @@ _asyncToGenerator(function* () {
   }]));
   var orders = instanceOf(Database);
   orders.collection_name = "orders";
-  assert.equal((yield optimizationsFor(orders, "SELECT total FROM orders WHERE status = 'paid'")), 0);
+  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 [[{
+test("a policy that returns undefined defers to the static lists", /*#__PURE__*/_asyncToGenerator(function* () {
+  for (var _ref33 of [[{
     SPICE_COUCHBASE_OPTIMIZE_RESOURCES: "users"
   }, 1], [{}, 0]]) {
+    var _ref32 = _slicedToArray(_ref33, 2);
+    var env = _ref32[0];
+    var expected = _ref32[1];
     var Database = loadDriver(3001, env);
     Database.setAutoOptimizePolicy(() => undefined);
-    assert.equal((yield optimizationsFor(instanceOf(Database), slowLookup)), expected);
+    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* () {
+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);
+    assert.equal(yield optimizationsFor(instanceOf(Database), slowLookup), 0);
   }
 }));
-test("the policy can be cleared and must be a function",
-/*#__PURE__*/
-_asyncToGenerator(function* () {
+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.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* () {
+test("a declined statement is not remembered as already optimised", /*#__PURE__*/_asyncToGenerator(function* () {
   var db = createUnconfiguredDatabase();
-  assert.equal((yield optimizationsFor(db, slowLookup)), 0);
+  assert.equal(yield optimizationsFor(db, slowLookup), 0);
   db.auto_optimize = true;
-  assert.equal((yield optimizationsFor(db, slowLookup)), 1);
+  assert.equal(yield optimizationsFor(db, slowLookup), 1);
 }));