spice-couchbase 2.0.61 → 2.0.63

package/build/index.js

@@ -24,6 +24,16 @@ var {
   QueryScanConsistency
 } = require("couchbase");
 
+var {
+  parseResourceList,
+  extractStatementResources
+} = require("./utility");
+
+var {
+  createHealthMonitor,
+  openHandles
+} = require("./connectionHealth");
+
 if (!Promise.allSettled) {
   Promise.allSettled = promises => Promise.all(promises.map((promise, i) => promise.then(value => ({
     status: "fulfilled",
@@ -52,8 +62,55 @@ var optimizeState = {
   inFlight: 0,
   seen: new Set(),
   cooldownUntil: 0
+}; // Auto cover indexing is opt-in per resource. A resource is the collection a
+// Database instance serves (scoped deployments) or the `type = '...'` literal
+// legacy bucket mode adds to every statement; raw statements also count their
+// FROM / JOIN keyspaces. Names are case-insensitive. A slow statement is
+// optimised when, in order of precedence:
+//   1. the call says so:        query_options.auto_optimize (true / false)
+//   2. the instance says so:    constructor option or connection config
+//                               `auto_optimize` (true / false)
+//   3. the application policy:  Database.setAutoOptimizePolicy(fn), where
+//                               fn(resource, context) returns true / false, or
+//                               undefined to defer to the static lists
+//   4. a static list names a resource it touches: comma-separated
+//      SPICE_COUCHBASE_OPTIMIZE_RESOURCES (`*` = every resource, which is the
+//      pre-2.0.62 behaviour), or connection config / constructor option
+//      `auto_optimize_resources`.
+
+var OPTIMIZE_ENABLED_RESOURCES = parseResourceList(process.env.SPICE_COUCHBASE_OPTIMIZE_RESOURCES);
+var autoOptimizePolicy = null; // One health monitor per process, shared by every copy of this module that
+// ends up loaded. See connectionHealth.js.
+
+var HEALTH_MONITOR_KEY = Symbol.for("spice-couchbase.health-monitor");
+var health = globalThis[HEALTH_MONITOR_KEY] || (globalThis[HEALTH_MONITOR_KEY] = createHealthMonitor()); // Cluster handles live on the `spice.database` globals, which a reconnect
+// replaces. Instances read them at call time instead of copying them.
+
+var HANDLE_GLOBALS = {
+  cluster: "clusters",
+  connection: "connections",
+  scope: "scopes",
+  bucket_handle: "buckets"
 };
 
+function globalHandle(kind, connection_name) {
+  var _spice, _spice$database, _spice$database$HANDL;
+
+  if (typeof spice === "undefined") return undefined;
+  return (_spice = spice) === null || _spice === void 0 ? void 0 : (_spice$database = _spice.database) === null || _spice$database === void 0 ? void 0 : (_spice$database$HANDL = _spice$database[HANDLE_GLOBALS[kind]]) === null || _spice$database$HANDL === void 0 ? void 0 : _spice$database$HANDL[connection_name];
+}
+
+function requestedAutoOptimize(query_options) {
+  var _query_options$auto_o;
+
+  if (!query_options || typeof query_options !== "object" || Array.isArray(query_options)) {
+    return undefined;
+  }
+
+  var value = (_query_options$auto_o = query_options.auto_optimize) !== null && _query_options$auto_o !== void 0 ? _query_options$auto_o : query_options.optimize;
+  return typeof value === "boolean" ? value : undefined;
+}
+
 function shouldOptimize(query) {
   if (!AUTO_OPTIMIZE_ENABLED) return false;
   if (optimizeState.inFlight >= OPTIMIZE_MAX_INFLIGHT) return false;
@@ -124,19 +181,18 @@ module.exports = class Database {
       collection,
       scope,
       query_scope = "cluster",
-      auto_create_collection
+      auto_create_collection,
+      auto_optimize,
+      auto_optimize_resources
     } = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
 
     if (connection) {
-      var _spice, _spice$db;
+      var _spice2, _spice2$db;
 
       this.connection_name = connection;
-      this.connection = spice.database.connections[connection];
       this.query_scope = query_scope;
-      this.cluster = spice.database.clusters[connection];
       this.bucket = this.connection._scope._bucket._name;
       this.db_config = spice.config.database.connections[connection];
-      this.collection_manager = spice.database.buckets[connection].collections();
       this.auto_create_collection = auto_create_collection || (collection || spice.config.database.connections[connection].collection) != undefined && (collection || spice.config.database.connections[connection].collection) != "default" && (scope || spice.config.database.connections[connection].scope) != "_default";
       this.collection_name = collection || spice.config.database.connections[connection].collection || "_default";
       /* console.log(
@@ -147,14 +203,11 @@ module.exports = class Database {
       );*/
 
       this.scope_name = scope || spice.config.database.connections[connection].scope || "_default";
-      this.scope = spice.database.scopes[connection];
       this.full_text_index = spice.config.database.connections[connection].full_text_index || full_text_index;
       this.N1qlQuery = couchbase.N1qlQuery;
       this.SearchQuery = couchbase.SearchQuery;
-      this.collection = this.scope.collection(this.collection_name);
-      this.userManager = this.getUserManager(connection);
 
-      if (!((_spice = spice) === null || _spice === void 0 ? void 0 : (_spice$db = _spice.db) === null || _spice$db === void 0 ? void 0 : _spice$db.collections)) {
+      if (!((_spice2 = spice) === null || _spice2 === void 0 ? void 0 : (_spice2$db = _spice2.db) === null || _spice2$db === void 0 ? void 0 : _spice2$db.collections)) {
         spice.db = spice.db || {};
         spice.db.collections = new Set();
       }
@@ -163,8 +216,255 @@ module.exports = class Database {
         this.upsertCollection();
       }
 
-      this.use_bucket_name = spice.config.database.connections[this.connection_name].scope == undefined;
+      this.use_bucket_name = spice.config.database.connections[this.connection_name].scope == undefined; // Auto cover indexing. See OPTIMIZE_ENABLED_RESOURCES for precedence.
+
+      var configured_auto_optimize = auto_optimize !== null && auto_optimize !== void 0 ? auto_optimize : this.db_config.auto_optimize;
+      this.auto_optimize = typeof configured_auto_optimize === "boolean" ? configured_auto_optimize : undefined;
+      this.enabled_resources = parseResourceList([...parseResourceList(this.db_config.auto_optimize_resources), ...parseResourceList(auto_optimize_resources)]);
+    }
+  } // Handles resolve from the globals on every access, so an instance created
+  // before a reconnect uses the new cluster afterwards. Assigning one pins it
+  // on that instance instead (tests, custom wiring).
+
+
+  pinHandle(kind, value) {
+    if (!Object.prototype.hasOwnProperty.call(this, "_pinned_handles")) {
+      Object.defineProperty(this, "_pinned_handles", {
+        value: {},
+        enumerable: false,
+        writable: true
+      });
+    }
+
+    this._pinned_handles[kind] = value;
+  }
+
+  pinnedHandle(kind) {
+    var pinned = this._pinned_handles;
+    return pinned && kind in pinned ? {
+      value: pinned[kind]
+    } : null;
+  }
+
+  handle(kind) {
+    var pinned = this.pinnedHandle(kind);
+    return pinned ? pinned.value : globalHandle(kind, this.connection_name);
+  }
+
+  get cluster() {
+    return this.handle("cluster");
+  }
+
+  set cluster(value) {
+    this.pinHandle("cluster", value);
+  }
+
+  get connection() {
+    return this.handle("connection");
+  }
+
+  set connection(value) {
+    this.pinHandle("connection", value);
+  }
+
+  get scope() {
+    return this.handle("scope");
+  }
+
+  set scope(value) {
+    this.pinHandle("scope", value);
+  }
+
+  get collection() {
+    var _this$_collection_cac;
+
+    var pinned = this.pinnedHandle("collection");
+    if (pinned) return pinned.value;
+    var scope = this.scope;
+    if (!scope) return undefined; // Collection handles are cheap but not free; cache one per scope object,
+    // which changes exactly when the connection is replaced.
+
+    if (((_this$_collection_cac = this._collection_cache) === null || _this$_collection_cac === void 0 ? void 0 : _this$_collection_cac.scope) !== scope) {
+      Object.defineProperty(this, "_collection_cache", {
+        value: {
+          scope,
+          collection: scope.collection(this.collection_name)
+        },
+        enumerable: false,
+        writable: true,
+        configurable: true
+      });
+    }
+
+    return this._collection_cache.collection;
+  }
+
+  set collection(value) {
+    this.pinHandle("collection", value);
+  }
+
+  get collection_manager() {
+    var _this$handle;
+
+    var pinned = this.pinnedHandle("collection_manager");
+    if (pinned) return pinned.value;
+    return (_this$handle = this.handle("bucket_handle")) === null || _this$handle === void 0 ? void 0 : _this$handle.collections();
+  }
+
+  set collection_manager(value) {
+    this.pinHandle("collection_manager", value);
+  }
+
+  get userManager() {
+    var _this$cluster;
+
+    var pinned = this.pinnedHandle("userManager");
+    if (pinned) return pinned.value;
+    return (_this$cluster = this.cluster) === null || _this$cluster === void 0 ? void 0 : _this$cluster.users();
+  }
+
+  set userManager(value) {
+    this.pinHandle("userManager", value);
+  }
+  /**
+   * Reports a finished operation to the health monitor. Only connectivity
+   * errors (timeouts, cancelled requests, service not available) count.
+   */
+
+
+  recordOutcome(error) {
+    health.recordOutcome(this.connection_name, error);
+  }
+
+  recordSettled(results) {
+    for (var result of results) {
+      if ((result === null || result === void 0 ? void 0 : result.status) === "rejected") this.recordOutcome(result.reason);
+    }
+  }
+
+  observe(operation) {
+    var _this = this;
+
+    return _asyncToGenerator(function* () {
+      try {
+        return yield operation;
+      } catch (error) {
+        _this.recordOutcome(error);
+
+        throw error;
+      }
+    })();
+  }
+  /** Per-connection health: healthy, reconnecting, generation, last error. */
+
+
+  static healthStatus() {
+    return health.status();
+  }
+  /** Probes a connection now and reconnects it if the probe fails. */
+
+
+  static checkHealth() {
+    var connection_name = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : "default";
+    return health.check(connection_name);
+  }
+  /** Opens a fresh cluster for a connection and swaps it in. */
+
+
+  static forceReconnect() {
+    var connection_name = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : "default";
+    return health.reconnect(connection_name);
+  }
+  /**
+   * Stops probing and reconnecting and closes replaced clusters still in
+   * their grace period. Call before closing `spice.database.clusters` on
+   * shutdown so a reconnect cannot race it.
+   */
+
+
+  static stopHealthMonitor() {
+    return health.stop();
+  }
+  /**
+   * Lets the application decide per resource whether slow statements may
+   * create covering indexes, e.g. from a per-resource setting an operator
+   * toggles at runtime. `policy(resource, { query, connection, collection })`
+   * returns true or false, or undefined to defer to the static lists. It is
+   * synchronous because it runs on the query path. Pass null to clear.
+   */
+
+
+  static setAutoOptimizePolicy(policy) {
+    if (policy !== null && policy !== undefined && typeof policy !== "function") {
+      throw new TypeError("Auto-optimize policy must be a function or null");
+    }
+
+    autoOptimizePolicy = policy || null;
+  }
+
+  static getAutoOptimizePolicy() {
+    return autoOptimizePolicy;
+  }
+  /**
+   * Resources a statement touches, plus this instance's collection: that is
+   * the keyspace `optimize()` would create the index on.
+   */
+
+
+  statementResources(query) {
+    var resources = extractStatementResources(query);
+
+    if (this.collection_name && this.collection_name !== "_default") {
+      resources.add(String(this.collection_name).toLowerCase());
+    }
+
+    return resources;
+  }
+  /**
+   * True when a slow statement may create a covering index. See
+   * OPTIMIZE_ENABLED_RESOURCES for the order of precedence.
+   */
+
+
+  shouldAutoOptimize(query) {
+    var query_options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+    var requested = requestedAutoOptimize(query_options);
+    if (requested !== undefined) return requested;
+    if (typeof this.auto_optimize === "boolean") return this.auto_optimize;
+    var resources = this.statementResources(query);
+
+    if (typeof autoOptimizePolicy === "function" && resources.size > 0) {
+      var deferred = false;
+
+      for (var resource of resources) {
+        var verdict = void 0;
+
+        try {
+          verdict = autoOptimizePolicy(resource, {
+            query,
+            connection: this.connection_name,
+            collection: this.collection_name
+          });
+        } catch (e) {
+          // A broken policy must not create indexes nobody asked for.
+          verdict = false;
+        }
+
+        if (verdict === true) return true;
+        if (verdict === undefined || verdict === null) deferred = true;
+      }
+
+      if (!deferred) return false;
     }
+
+    var enabled = new Set([...OPTIMIZE_ENABLED_RESOURCES, ...(this.enabled_resources || [])]);
+    if (enabled.has("*")) return true;
+
+    for (var _resource of resources) {
+      if (enabled.has(_resource)) return true;
+    }
+
+    return false;
   }
 
   setGlobalConnectionObject(collection) {
@@ -189,25 +489,15 @@ module.exports = class Database {
   }
 
   connect(connection_name, config) {
-    var _this = this;
-
     return _asyncToGenerator(function* () {
-      var connectOptions = {
-        username: config.username,
-        password: config.password
-      };
-
-      if (config.configProfile) {
-        connectOptions.configProfile = config.configProfile;
-      }
+      var {
+        cluster,
+        bucket,
+        scope,
+        collection
+      } = yield openHandles(config); // Watch the connection from here on and replace it if it wedges.
 
-      var cluster = yield couchbase.connect(config.nodes, connectOptions);
-      var bucket = cluster.bucket(config.bucket);
-      var collection;
-      var scope_name = _this.scope_name || config.scope || "_default";
-      var collection_name = _this.collection_name || config.collection || "_default";
-      var scope = bucket.scope(scope_name);
-      collection = bucket.scope(scope_name).collection(collection_name || "_default");
+      health.register(connection_name, config);
       return {
         connection: connection_name,
         bucket,
@@ -219,7 +509,7 @@ module.exports = class Database {
   }
 
   getUserManager(connection) {
-    return spice.database.clusters[connection].users();
+    return globalHandle("cluster", connection).users();
   }
 
   assignUserPermission() {
@@ -292,9 +582,9 @@ module.exports = class Database {
 
     return _asyncToGenerator(function* () {
       try {
-        var _spice2, _spice2$db, _spice2$db$collection;
+        var _spice3, _spice3$db, _spice3$db$collection;
 
-        if ((_spice2 = spice) === null || _spice2 === void 0 ? void 0 : (_spice2$db = _spice2.db) === null || _spice2$db === void 0 ? void 0 : (_spice2$db$collection = _spice2$db.collections) === null || _spice2$db$collection === void 0 ? void 0 : _spice2$db$collection.has(collection_name)) {
+        if ((_spice3 = spice) === null || _spice3 === void 0 ? void 0 : (_spice3$db = _spice3.db) === null || _spice3$db === void 0 ? void 0 : (_spice3$db$collection = _spice3$db.collections) === null || _spice3$db$collection === void 0 ? void 0 : _spice3$db$collection.has(collection_name)) {
           return true;
         } else {
           var response = yield _this4.cluster.query("SELECT RAW keyspace_id\n           FROM system:keyspaces\n           WHERE bucket_id = ?\n             AND scope_id = ?\n             AND keyspace_id = ?\n           LIMIT 1", {
@@ -405,7 +695,7 @@ module.exports = class Database {
         var collection = _this9.use_bucket_name ? _this9.connection : _this9.collection;
 
         if (!useLookupIn) {
-          var response = yield collection.get(doc_id);
+          var response = yield _this9.observe(collection.get(doc_id));
           return _objectSpread({
             id: doc_id
           }, response.content);
@@ -423,7 +713,10 @@ module.exports = class Database {
           var specs = batch.map(col => couchbase.LookupInSpec.get(col));
           return collection.lookupIn(doc_id, specs);
         });
-        var batchResults = yield Promise.allSettled(batchPromises); // Merge results from all batches
+        var batchResults = yield Promise.allSettled(batchPromises);
+
+        _this9.recordSettled(batchResults); // Merge results from all batches
+
 
         batchResults.forEach((result, batchIndex) => {
           if (result.status === "fulfilled" && result.value) {
@@ -447,9 +740,9 @@ module.exports = class Database {
 
     return _asyncToGenerator(function* () {
       try {
-        yield (_this10.use_bucket_name ? _this10.connection : _this10.collection).insert(doc_id, document, {
+        yield _this10.observe((_this10.use_bucket_name ? _this10.connection : _this10.collection).insert(doc_id, document, {
           expiry: expiry
-        });
+        }));
       } catch (e) {
         console.log(e.message, e, doc_id);
       }
@@ -463,7 +756,7 @@ module.exports = class Database {
 
     var expiry = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0;
     return _asyncToGenerator(function* () {
-      yield (_this11.use_bucket_name ? _this11.connection : _this11.collection).touch(doc_id, expiry);
+      yield _this11.observe((_this11.use_bucket_name ? _this11.connection : _this11.collection).touch(doc_id, expiry));
       return yield _this11.get(doc_id);
     })();
   }
@@ -472,9 +765,9 @@ module.exports = class Database {
     var _this12 = this;
 
     return _asyncToGenerator(function* () {
-      var res = yield (_this12.use_bucket_name ? _this12.connection : _this12.collection).counter(doc_id, adjustment, {
+      var res = yield _this12.observe((_this12.use_bucket_name ? _this12.connection : _this12.collection).counter(doc_id, adjustment, {
         initial: initial_value
-      });
+      }));
       return res.value;
     })();
   }
@@ -483,9 +776,9 @@ module.exports = class Database {
     var _this13 = this;
 
     return _asyncToGenerator(function* () {
-      var res = yield (_this13.use_bucket_name ? _this13.connection : _this13.collection).replace(doc_id, document, {
+      var res = yield _this13.observe((_this13.use_bucket_name ? _this13.connection : _this13.collection).replace(doc_id, document, {
         expiry: expiry
-      });
+      }));
       return res.value;
     })();
   }
@@ -494,7 +787,7 @@ module.exports = class Database {
     var _this14 = this;
 
     return _asyncToGenerator(function* () {
-      var res = yield (_this14.use_bucket_name ? _this14.connection : _this14.collection).remove(doc_id);
+      var res = yield _this14.observe((_this14.use_bucket_name ? _this14.connection : _this14.collection).remove(doc_id));
       return res.value;
     })();
   }
@@ -521,6 +814,8 @@ module.exports = class Database {
 
           var returned_all = yield Promise.allSettled(functions);
 
+          _this15.recordSettled(returned_all);
+
           var responses = _.flatten(_.map(returned_all, returned_obj => returned_obj === null || returned_obj === void 0 ? void 0 : returned_obj.value));
 
           var _final_responses = _.compact(_.map(responses, (res, index) => {
@@ -559,7 +854,10 @@ module.exports = class Database {
                 var specs = batch.map(col => couchbase.LookupInSpec.get(col));
                 return collection.lookupIn(key, specs);
               });
-              var batchResults = yield Promise.allSettled(batchPromises); // Merge results from all batches
+              var batchResults = yield Promise.allSettled(batchPromises);
+
+              _this15.recordSettled(batchResults); // Merge results from all batches
+
 
               batchResults.forEach((result, batchIndex) => {
                 if (result.status === "fulfilled" && result.value) {
@@ -986,14 +1284,14 @@ module.exports = class Database {
 
       var startTime = process.hrtime.bigint();
       var options = buildQueryOptions(query_options);
-      var response = yield exec_scope.query(sanitizedQuery, options); // End time
+      var response = yield _this20.observe(exec_scope.query(sanitizedQuery, options)); // End time
 
       var endTime = process.hrtime.bigint(); // Calculate duration in microseconds
 
       var durationInMilliseconds = (endTime - startTime) / BigInt(1000000); // Optimise slow statements in the background, subject to the guard rails
       // declared at the top of this file. Never awaited, never allowed to reject.
 
-      if (durationInMilliseconds > SLOW_QUERY_MS && shouldOptimize(sanitizedQuery)) {
+      if (durationInMilliseconds > SLOW_QUERY_MS && _this20.shouldAutoOptimize(sanitizedQuery, query_options) && shouldOptimize(sanitizedQuery)) {
         _this20.optimize(sanitizedQuery, exec_scope).catch(() => {});
       }
 

package/build/utility.js

@@ -435,11 +435,76 @@ function indexSatisfiesCoveringDefinition(index, candidate) {
   var existingFields = new Set(existingKeys.map(key => key.field));
   return requiredKeys.slice(candidate.accessKeyCount).every(key => existingFields.has(key.field));
 }
+/**
+ * Normalizes an exemption list into a Set of lower-case resource names.
+ * Accepts an array, a Set, or a comma-separated string (the env var form).
+ * Surrounding whitespace and backticks are ignored; empty entries are dropped.
+ * @param {string|string[]|Set<string>} value
+ * @returns {Set<string>}
+ */
+
+
+function parseResourceList(value) {
+  var names = new Set();
+  var items = [];
+
+  if (Array.isArray(value) || value instanceof Set) {
+    items = [...value];
+  } else if (typeof value === "string") {
+    items = value.split(",");
+  }
+
+  for (var item of items) {
+    if (typeof item !== "string") continue;
+    var name = item.trim().replace(/^`+|`+$/g, "").trim().toLowerCase();
+    if (name) names.add(name);
+  }
+
+  return names;
+}
+/**
+ * Extracts the resource names a statement touches, lower-cased:
+ * - the last path segment of every FROM / JOIN keyspace, unquoted, so
+ *   `default`:`bucket`.`scope`.`users` and users both yield "users";
+ * - every `type = '...'` literal, which is how legacy bucket-mode
+ *   deployments distinguish resources that share one keyspace.
+ * Only simple identifiers are recognised; subqueries and expressions are skipped.
+ * @param {string} query
+ * @returns {Set<string>}
+ */
+
+
+function extractStatementResources(query) {
+  var names = new Set();
+  if (typeof query !== "string") return names;
+  var identifier = "(?:`(?:[^`]|``)+`|[A-Za-z_][\\w$-]*)";
+  var keyspacePattern = new RegExp("\\b(?:FROM|JOIN)\\s+(".concat(identifier, "(?:\\s*[.:]\\s*").concat(identifier, ")*)"), "gi");
+  var segmentPattern = new RegExp(identifier, "g");
+
+  for (var match of query.matchAll(keyspacePattern)) {
+    var segments = match[1].match(segmentPattern) || [];
+    var last = (segments[segments.length - 1] || "").trim();
+    var name = last.startsWith("`") ? last.slice(1, -1).replace(/``/g, "`") : last;
+    if (name) names.add(name.toLowerCase());
+  }
+
+  var typePattern = /(?:`type`|\btype)\s*=\s*'((?:[^']|'')*)'/gi;
+
+  for (var _match of query.matchAll(typePattern)) {
+    var _name = _match[1].replace(/''/g, "'").trim();
+
+    if (_name) names.add(_name.toLowerCase());
+  }
+
+  return names;
+}
 
 module.exports = {
   buildCoveringIndex,
   buildCoveringIndexDefinition,
   indexSatisfiesCoveringDefinition,
+  parseResourceList,
+  extractStatementResources,
   extractWhereFields,
   extractSelectFields,
   extractGroupByFields,

package/build/utility.test.js

@@ -8,7 +8,9 @@ var {
   extractSelectFields,
   extractGroupByFields,
   extractOrderByFields,
-  generateHash
+  generateHash,
+  parseResourceList,
+  extractStatementResources
 } = require("./utility"); // Test utilities
 
 
@@ -825,6 +827,52 @@ test("field order: WHERE -> GROUP BY -> ORDER BY -> SELECT", () => {
 
   assert.ok(createdAtIndex < emailIndex); // ORDER BY before SELECT
 }); // ============================================
+// Tests for parseResourceList / extractStatementResources
+// ============================================
+
+console.log("\n--- parseResourceList tests ---");
+test("parses a comma-separated string, trimming, unquoting and lower-casing", () => {
+  var result = parseResourceList(" Users, `Audit_Log` ,, sessions ");
+  assert.deepStrictEqual([...result].sort(), ["audit_log", "sessions", "users"]);
+});
+test("accepts arrays and Sets and ignores non-strings", () => {
+  assert.deepStrictEqual([...parseResourceList(["Users", 42, null, " logs "])].sort(), ["logs", "users"]);
+  assert.deepStrictEqual([...parseResourceList(new Set(["A", "b"]))].sort(), ["a", "b"]);
+});
+test("returns an empty set for undefined, empty or unsupported input", () => {
+  assert.strictEqual(parseResourceList(undefined).size, 0);
+  assert.strictEqual(parseResourceList("").size, 0);
+  assert.strictEqual(parseResourceList(", ,").size, 0);
+  assert.strictEqual(parseResourceList({
+    users: true
+  }).size, 0);
+});
+console.log("\n--- extractStatementResources tests ---");
+test("extracts a bare FROM keyspace", () => {
+  assert.deepStrictEqual([...extractStatementResources("SELECT name FROM users WHERE x = 1")], ["users"]);
+});
+test("extracts the last segment of a qualified or quoted keyspace", () => {
+  assert.deepStrictEqual([...extractStatementResources("SELECT name FROM `default`:`saturn`.`app`.`Users` AS u")], ["users"]);
+  assert.deepStrictEqual([...extractStatementResources("SELECT name FROM saturn.app.logs")], ["logs"]);
+});
+test("extracts JOIN keyspaces alongside FROM", () => {
+  var result = extractStatementResources("SELECT u.name FROM users AS u JOIN `orders` AS o ON o.user_id = META(u).id");
+  assert.deepStrictEqual([...result].sort(), ["orders", "users"]);
+});
+test("extracts type literals used by legacy bucket mode", () => {
+  var result = extractStatementResources("SELECT actor FROM `saturn` WHERE type = 'Audit_Log' AND deleted = false");
+  assert.deepStrictEqual([...result].sort(), ["audit_log", "saturn"]);
+  assert.ok(extractStatementResources("SELECT a FROM b WHERE `type`='x'").has("x"));
+  assert.ok(extractStatementResources("SELECT a FROM b WHERE type = 'it''s'").has("it's"));
+});
+test("does not treat META() arguments, subqueries or column names as keyspaces", () => {
+  var result = extractStatementResources("SELECT META(`users`).id AS id, from_date FROM (SELECT * FROM users) AS sub WHERE status = 'from'");
+  assert.deepStrictEqual([...result], ["users"]);
+});
+test("handles non-string input", () => {
+  assert.strictEqual(extractStatementResources(undefined).size, 0);
+  assert.strictEqual(extractStatementResources(null).size, 0);
+}); // ============================================
 // Summary
 // ============================================
 

package/package.json

@@ -1,13 +1,14 @@
 {
   "name": "spice-couchbase",
-  "version": "2.0.61",
+  "version": "2.0.63",
   "description": "",
   "main": "build/index.js",
   "scripts": {
     "test": "node src/utility.test.js",
     "test:auto-optimize": "node --test src/index.auto-optimize.test.js",
     "test:query-consistency": "node src/index.query-consistency.test.js",
-    "test:count-query": "node src/index.count-query.test.js"
+    "test:count-query": "node src/index.count-query.test.js",
+    "test:connection-health": "node --test src/connectionHealth.test.js"
   },
   "author": "Chad Fraser <chad@sonover.com> (http://sonover.com)",
   "license": "ISC",