spice-couchbase 2.0.64 → 2.0.65

package/build/utility.test.js

@@ -1,22 +1,19 @@
 "use strict";
 
 var assert = require("assert");
-
-var {
-  buildCoveringIndex,
-  extractWhereFields,
-  extractSelectFields,
-  extractGroupByFields,
-  extractOrderByFields,
-  generateHash,
-  parseResourceList,
-  extractStatementResources
-} = require("./utility"); // Test utilities
-
-
+var _require = require("./utility"),
+  buildCoveringIndex = _require.buildCoveringIndex,
+  extractWhereFields = _require.extractWhereFields,
+  extractSelectFields = _require.extractSelectFields,
+  extractGroupByFields = _require.extractGroupByFields,
+  extractOrderByFields = _require.extractOrderByFields,
+  generateHash = _require.generateHash,
+  parseResourceList = _require.parseResourceList,
+  extractStatementResources = _require.extractStatementResources;
+
+// Test utilities
 var passed = 0;
 var failed = 0;
-
 function test(name, fn) {
   try {
     fn();
@@ -28,17 +25,16 @@ function test(name, fn) {
     failed++;
   }
 }
-
 function arraysEqual(a, b) {
   if (a.length !== b.length) return false;
   var sortedA = [...a].sort();
   var sortedB = [...b].sort();
   return sortedA.every((val, i) => val === sortedB[i]);
-} // ============================================
+}
+
+// ============================================
 // Tests for generateHash
 // ============================================
-
-
 console.log("\n--- generateHash tests ---");
 test("generates 8 character hash", () => {
   var hash = generateHash("test query");
@@ -53,10 +49,11 @@ test("generates different hash for different input", () => {
   var hash1 = generateHash("SELECT * FROM users");
   var hash2 = generateHash("SELECT * FROM orders");
   assert.notStrictEqual(hash1, hash2);
-}); // ============================================
+});
+
+// ============================================
 // Tests for extractWhereFields
 // ============================================
-
 console.log("\n--- extractWhereFields tests ---");
 test("extracts simple equality field", () => {
   var query = "SELECT name FROM users WHERE status = 'active'";
@@ -225,10 +222,11 @@ test("handles complex ANY with deleted pattern", () => {
   assert.ok(fields.includes("deleted"));
   assert.ok(fields.includes("status"));
   assert.ok(fields.includes("tags"));
-}); // ============================================
+});
+
+// ============================================
 // Tests for extractSelectFields
 // ============================================
-
 console.log("\n--- extractSelectFields tests ---");
 test("extracts simple field", () => {
   var query = "SELECT name FROM users";
@@ -294,8 +292,8 @@ test("handles multiple aggregate functions", () => {
 });
 test("handles nested function calls", () => {
   var query = "SELECT LOWER(TRIM(name)) AS clean_name FROM users";
-  var fields = extractSelectFields(query); // Should extract 'name' from nested functions - currently extracts last match
-
+  var fields = extractSelectFields(query);
+  // Should extract 'name' from nested functions - currently extracts last match
   assert.ok(fields.length >= 0); // At minimum should not crash
 });
 test("handles query with JOIN", () => {
@@ -324,10 +322,11 @@ test("handles backtick collection prefix", () => {
   var fields = extractSelectFields(query);
   assert.ok(fields.includes("first_name"));
   assert.ok(fields.includes("last_name"));
-}); // ============================================
+});
+
+// ============================================
 // Tests for extractGroupByFields
 // ============================================
-
 console.log("\n--- extractGroupByFields tests ---");
 test("extracts simple GROUP BY field", () => {
   var query = "SELECT status, COUNT(*) FROM users GROUP BY status";
@@ -378,10 +377,11 @@ test("handles GROUP BY with HAVING and ORDER BY", () => {
   var query = "SELECT status, COUNT(*) FROM users GROUP BY status HAVING COUNT(*) > 5 ORDER BY status";
   var fields = extractGroupByFields(query);
   assert.ok(arraysEqual(fields, ["status"]));
-}); // ============================================
+});
+
+// ============================================
 // Tests for extractOrderByFields
 // ============================================
-
 console.log("\n--- extractOrderByFields tests ---");
 test("extracts simple ORDER BY field", () => {
   var query = "SELECT name FROM users ORDER BY created_at";
@@ -442,10 +442,11 @@ test("handles mixed ASC and DESC", () => {
   var query = "SELECT name FROM users ORDER BY last_name ASC, created_at DESC";
   var fields = extractOrderByFields(query);
   assert.ok(arraysEqual(fields, ["last_name", "created_at"]));
-}); // ============================================
+});
+
+// ============================================
 // Tests for buildCoveringIndex
 // ============================================
-
 console.log("\n--- buildCoveringIndex tests ---");
 var defaultOptions = {
   bucket: "saturn",
@@ -479,16 +480,18 @@ test("WHERE fields come before SELECT fields", () => {
 });
 test("deduplicates fields in WHERE and SELECT", () => {
   var query = "SELECT status, name FROM users WHERE status = 'active'";
-  var result = buildCoveringIndex(query, defaultOptions); // status should only appear once
+  var result = buildCoveringIndex(query, defaultOptions);
 
+  // status should only appear once
   var firstStatus = result.indexOf("`status`");
   var lastStatus = result.lastIndexOf("`status`");
   assert.strictEqual(firstStatus, lastStatus);
 });
 test("excludes deleted from WHERE fields (added separately)", () => {
   var query = "SELECT name FROM users WHERE (deleted = false OR deleted IS MISSING) AND status = 'active'";
-  var result = buildCoveringIndex(query, defaultOptions); // deleted should only appear once (as INCLUDE MISSING)
+  var result = buildCoveringIndex(query, defaultOptions);
 
+  // deleted should only appear once (as INCLUDE MISSING)
   var matches = result.match(/`deleted`/g);
   assert.strictEqual(matches.length, 1);
   assert.ok(result.includes("`deleted` INCLUDE MISSING"));
@@ -526,8 +529,9 @@ test("generates unique index name from query hash", () => {
   var query1 = "SELECT name FROM users WHERE status = 'active'";
   var query2 = "SELECT email FROM users WHERE type = 'admin'";
   var result1 = buildCoveringIndex(query1, defaultOptions);
-  var result2 = buildCoveringIndex(query2, defaultOptions); // Extract index names
+  var result2 = buildCoveringIndex(query2, defaultOptions);
 
+  // Extract index names
   var name1 = result1.match(/CREATE INDEX `(adv_covered_\w+)`/)[1];
   var name2 = result2.match(/CREATE INDEX `(adv_covered_\w+)`/)[1];
   assert.notStrictEqual(name1, name2);
@@ -545,8 +549,8 @@ test("handles complex query with multiple conditions", () => {
 });
 test("returns null when only deleted field in query", () => {
   var query = "SELECT deleted FROM users WHERE deleted = false";
-  var result = buildCoveringIndex(query, defaultOptions); // Should return null because after filtering out 'deleted', there are no fields left
-
+  var result = buildCoveringIndex(query, defaultOptions);
+  // Should return null because after filtering out 'deleted', there are no fields left
   assert.strictEqual(result, null);
 });
 test("handles query with type field (legacy pattern)", () => {
@@ -593,11 +597,13 @@ test("same index name for different queries with same fields", () => {
   var query1 = "SELECT name, email FROM users WHERE status = 'active'";
   var query2 = "SELECT email, name FROM users WHERE status = 'pending'";
   var result1 = buildCoveringIndex(query1, defaultOptions);
-  var result2 = buildCoveringIndex(query2, defaultOptions); // Extract index names
+  var result2 = buildCoveringIndex(query2, defaultOptions);
 
+  // Extract index names
   var name1 = result1.match(/CREATE INDEX `(adv_covered_\w+)`/)[1];
-  var name2 = result2.match(/CREATE INDEX `(adv_covered_\w+)`/)[1]; // Should have the same index name since they have the same fields
+  var name2 = result2.match(/CREATE INDEX `(adv_covered_\w+)`/)[1];
 
+  // Should have the same index name since they have the same fields
   assert.strictEqual(name1, name2);
 });
 test("different index name for different ORDER BY direction", () => {
@@ -622,17 +628,20 @@ test("different index name for queries with different fields", () => {
   var query1 = "SELECT name FROM users WHERE status = 'active'";
   var query2 = "SELECT email FROM users WHERE type = 'admin'";
   var result1 = buildCoveringIndex(query1, defaultOptions);
-  var result2 = buildCoveringIndex(query2, defaultOptions); // Extract index names
+  var result2 = buildCoveringIndex(query2, defaultOptions);
 
+  // Extract index names
   var name1 = result1.match(/CREATE INDEX `(adv_covered_\w+)`/)[1];
-  var name2 = result2.match(/CREATE INDEX `(adv_covered_\w+)`/)[1]; // Should have different index names since they have different fields
+  var name2 = result2.match(/CREATE INDEX `(adv_covered_\w+)`/)[1];
 
+  // Should have different index names since they have different fields
   assert.notStrictEqual(name1, name2);
 });
 test("index includes all fields needed for covering", () => {
   var query = "SELECT \n    first_name, \n    middle_name, \n    last_name, \n    status, \n    constituency, \n    division, \n    description \n  FROM subject \n  WHERE (deleted = false OR deleted IS MISSING) \n    AND created_at > '2024-01-01'";
-  var result = buildCoveringIndex(query, defaultOptions); // Verify structure matches the working example pattern
+  var result = buildCoveringIndex(query, defaultOptions);
 
+  // Verify structure matches the working example pattern
   assert.ok(result.startsWith("CREATE INDEX `adv_covered_"));
   assert.ok(result.includes("`deleted` INCLUDE MISSING"));
   assert.ok(result.includes("`created_at`"));
@@ -688,16 +697,18 @@ test("ORDER BY fields come after WHERE fields", () => {
   var result = buildCoveringIndex(query, defaultOptions);
   var statusIndex = result.indexOf("`status`");
   var createdAtIndex = result.indexOf("`created_at`");
-  var emailIndex = result.indexOf("`email`"); // WHERE field (status) should come before ORDER BY field (created_at)
-
-  assert.ok(statusIndex < createdAtIndex); // ORDER BY field (created_at) should come before SELECT field (email)
+  var emailIndex = result.indexOf("`email`");
 
+  // WHERE field (status) should come before ORDER BY field (created_at)
+  assert.ok(statusIndex < createdAtIndex);
+  // ORDER BY field (created_at) should come before SELECT field (email)
   assert.ok(createdAtIndex < emailIndex);
 });
 test("deduplicates ORDER BY field if already in WHERE", () => {
   var query = "SELECT name FROM users WHERE status = 'active' AND created_at > '2024-01-01' ORDER BY created_at DESC";
-  var result = buildCoveringIndex(query, defaultOptions); // created_at should only appear once
+  var result = buildCoveringIndex(query, defaultOptions);
 
+  // created_at should only appear once
   var firstCreatedAt = result.indexOf("`created_at`");
   var lastCreatedAt = result.lastIndexOf("`created_at`");
   assert.strictEqual(firstCreatedAt, lastCreatedAt);
@@ -705,8 +716,9 @@ test("deduplicates ORDER BY field if already in WHERE", () => {
 });
 test("deduplicates ORDER BY field if already in SELECT", () => {
   var query = "SELECT name, created_at FROM users WHERE status = 'active' ORDER BY created_at DESC";
-  var result = buildCoveringIndex(query, defaultOptions); // created_at should only appear once (in ORDER BY position, before SELECT fields)
+  var result = buildCoveringIndex(query, defaultOptions);
 
+  // created_at should only appear once (in ORDER BY position, before SELECT fields)
   var matches = result.match(/`created_at`/g);
   assert.strictEqual(matches.length, 1);
   assert.ok(result.includes("`created_at` DESC"));
@@ -715,8 +727,9 @@ test("handles multiple ORDER BY fields", () => {
   var query = "SELECT email FROM users WHERE status = 'active' ORDER BY last_name ASC, first_name ASC";
   var result = buildCoveringIndex(query, defaultOptions);
   assert.ok(result.includes("`last_name`"));
-  assert.ok(result.includes("`first_name`")); // ORDER BY fields should come before SELECT fields
+  assert.ok(result.includes("`first_name`"));
 
+  // ORDER BY fields should come before SELECT fields
   var lastNameIndex = result.indexOf("`last_name`");
   var firstNameIndex = result.indexOf("`first_name`");
   var emailIndex = result.indexOf("`email`");
@@ -739,8 +752,9 @@ test("handles realistic query with ORDER BY", () => {
   assert.ok(result.includes("`created_at` DESC"));
   assert.ok(result.includes("`first_name`"));
   assert.ok(result.includes("`last_name`"));
-  assert.ok(result.includes("`email`")); // Verify order: status (WHERE) -> created_at (ORDER BY) -> SELECT fields
+  assert.ok(result.includes("`email`"));
 
+  // Verify order: status (WHERE) -> created_at (ORDER BY) -> SELECT fields
   var statusIndex = result.indexOf("`status`");
   var createdAtIndex = result.indexOf("`created_at`");
   var firstNameIndex = result.indexOf("`first_name`");
@@ -760,25 +774,29 @@ test("GROUP BY fields come after WHERE fields", () => {
   var query = "SELECT COUNT(name) FROM users WHERE type = 'user' GROUP BY status";
   var result = buildCoveringIndex(query, defaultOptions);
   var typeIndex = result.indexOf("`type`");
-  var statusIndex = result.indexOf("`status`"); // WHERE field (type) should come before GROUP BY field (status)
+  var statusIndex = result.indexOf("`status`");
 
+  // WHERE field (type) should come before GROUP BY field (status)
   assert.ok(typeIndex < statusIndex);
 });
 test("GROUP BY fields come before ORDER BY fields", () => {
   var query = "SELECT COUNT(name) FROM users WHERE type = 'user' GROUP BY status ORDER BY status";
   var result = buildCoveringIndex(query, defaultOptions);
   var typeIndex = result.indexOf("`type`");
-  var statusIndex = result.indexOf("`status`"); // status is in both GROUP BY and ORDER BY, should only appear once
+  var statusIndex = result.indexOf("`status`");
 
+  // status is in both GROUP BY and ORDER BY, should only appear once
   var matches = result.match(/`status`/g);
-  assert.strictEqual(matches.length, 1); // WHERE field (type) should come before GROUP BY field (status)
+  assert.strictEqual(matches.length, 1);
 
+  // WHERE field (type) should come before GROUP BY field (status)
   assert.ok(typeIndex < statusIndex);
 });
 test("deduplicates GROUP BY field if already in WHERE", () => {
   var query = "SELECT COUNT(name) FROM users WHERE status = 'active' GROUP BY status";
-  var result = buildCoveringIndex(query, defaultOptions); // status should only appear once
+  var result = buildCoveringIndex(query, defaultOptions);
 
+  // status should only appear once
   var matches = result.match(/`status`/g);
   assert.strictEqual(matches.length, 1);
 });
@@ -805,8 +823,9 @@ test("handles realistic GROUP BY query", () => {
   assert.ok(result.includes("`deleted` INCLUDE MISSING"));
   assert.ok(result.includes("`type`"));
   assert.ok(result.includes("`status`"));
-  assert.ok(result.includes("`first_name`")); // Verify order: type (WHERE) -> status (GROUP BY) -> first_name (SELECT)
+  assert.ok(result.includes("`first_name`"));
 
+  // Verify order: type (WHERE) -> status (GROUP BY) -> first_name (SELECT)
   var typeIndex = result.indexOf("`type`");
   var statusIndex = result.indexOf("`status`");
   var firstNameIndex = result.indexOf("`first_name`");
@@ -819,17 +838,17 @@ test("field order: WHERE -> GROUP BY -> ORDER BY -> SELECT", () => {
   var typeIndex = result.indexOf("`type`");
   var statusIndex = result.indexOf("`status`");
   var createdAtIndex = result.indexOf("`created_at`");
-  var emailIndex = result.indexOf("`email`"); // Verify correct order
+  var emailIndex = result.indexOf("`email`");
 
+  // Verify correct order
   assert.ok(typeIndex < statusIndex); // WHERE before GROUP BY
-
   assert.ok(statusIndex < createdAtIndex); // GROUP BY before ORDER BY
-
   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 ");
@@ -872,10 +891,11 @@ test("does not treat META() arguments, subqueries or column names as keyspaces",
 test("handles non-string input", () => {
   assert.strictEqual(extractStatementResources(undefined).size, 0);
   assert.strictEqual(extractStatementResources(null).size, 0);
-}); // ============================================
+});
+
+// ============================================
 // Summary
 // ============================================
-
 console.log("\n========================================");
 console.log("Tests: ".concat(passed + failed, " | Passed: ").concat(passed, " | Failed: ").concat(failed));
 console.log("========================================\n");

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "spice-couchbase",
-  "version": "2.0.64",
+  "version": "2.0.65",
   "description": "",
   "main": "build/index.js",
   "scripts": {

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

@@ -0,0 +1,232 @@
+"use strict";
+
+const assert = require("node:assert/strict");
+const fs = require("node:fs");
+const path = require("node:path");
+const vm = require("node:vm");
+const { test } = require("node:test");
+const {
+  statementShape,
+  planIndexNames,
+  usesManagedIndex,
+  renderIndexKey,
+  BASE_INDEX,
+} = require("./utility");
+
+// 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, env = {}) {
+  let tick = BigInt(0);
+  const module = { exports: {} };
+  vm.runInNewContext(fs.readFileSync(path.join(__dirname, "index.js"), "utf8"), {
+    require,
+    module,
+    console,
+    process: {
+      env,
+      hrtime: {
+        bigint: () => {
+          const current = tick;
+          tick += BigInt(durationMs) * BigInt(1000000);
+          return current;
+        },
+      },
+    },
+  });
+  return module.exports;
+}
+
+function recordingCluster(rowsFor = () => []) {
+  const calls = [];
+  return {
+    calls,
+    async query(statement, options) {
+      calls.push({ statement, options });
+      return { rows: rowsFor(statement), meta: {} };
+    },
+  };
+}
+
+function createDatabase(Database, cluster) {
+  const 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;
+}
+
+const 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", () => {
+  const 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", async () => {
+  const cluster = recordingCluster();
+  const db = createDatabase(loadDriver(0), cluster);
+  await 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 ${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", async () => {
+  const cluster = recordingCluster();
+  const db = createDatabase(loadDriver(0), cluster);
+  await db.buildIndexes(["ix_a", "ix_b", "ix_a"]);
+  await db.dropIndex("ix_a");
+  await db.dropPrimaryIndex();
+  assert.deepEqual(cluster.calls.map(({ statement }) => statement), [
+    `BUILD INDEX ON ${KEYSPACE}(\`ix_a\`, \`ix_b\`)`,
+    `DROP INDEX IF EXISTS \`ix_a\` ON ${KEYSPACE}`,
+    `DROP PRIMARY INDEX IF EXISTS ON ${KEYSPACE}`,
+  ]);
+  assert.equal(await db.buildIndexes([]), null);
+});
+
+test("a partial index inventory is an error, not an empty list", async () => {
+  const Database = loadDriver(0);
+  const db = createDatabase(Database, {
+    async query() {
+      return { rows: [], meta: { warnings: [{ msg: "partial" }] } };
+    },
+  });
+  await assert.rejects(() => db.listIndexes(), /index inventory/);
+});
+
+test("the client context id reaches the SDK options", async () => {
+  const cluster = recordingCluster();
+  const db = createDatabase(loadDriver(0), cluster);
+  await db.query("SELECT 1", "cluster", { client_context_id: "scheduler.due" });
+  assert.equal(cluster.calls[0].options.clientContextId, "scheduler.due");
+});
+
+function scanTimeout() {
+  const 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", async () => {
+  const Database = loadDriver(0);
+  const attempts = [];
+  const cluster = {
+    async query(statement, options) {
+      attempts.push(options);
+      if (attempts.length === 1) throw scanTimeout();
+      return { rows: [{ ok: true }] };
+    },
+  };
+  const db = createDatabase(Database, cluster);
+  const response = await 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", async () => {
+  const Database = loadDriver(0);
+  const db = createDatabase(Database, {
+    async query() {
+      throw scanTimeout();
+    },
+  });
+  await 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", async () => {
+  const Database = loadDriver(5000);
+  const cluster = recordingCluster((statement) =>
+    statement.startsWith("EXPLAIN ") ? [{ "#operator": "IndexScan3", index: "ix_base" }] : [],
+  );
+  const db = createDatabase(Database, cluster);
+  const reports = [];
+  Database.setSlowStatementHandler(async (report) => reports.push(report));
+  let legacy = 0;
+  db.optimize = async () => { legacy += 1; };
+
+  await db.query("SELECT name FROM users WHERE email = 'a@b.c'");
+  await db.query("SELECT name FROM users WHERE email = 'd@e.f'");
+  await 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(({ statement }) => statement.startsWith("CREATE ")), false);
+});
+
+test("a slow statement already served by a managed index is not reported", async () => {
+  const Database = loadDriver(5000);
+  const cluster = recordingCluster((statement) =>
+    statement.startsWith("EXPLAIN ") ? [{ "#operator": "IndexScan3", index: "ix_sort_1a2b3c_9f0e" }] : [],
+  );
+  const db = createDatabase(Database, cluster);
+  const reports = [];
+  Database.setSlowStatementHandler(async (report) => reports.push(report));
+  await db.query("SELECT name FROM users ORDER BY priority DESC");
+  await new Promise((resolve) => setImmediate(resolve));
+  assert.equal(reports.length, 0);
+});
+
+test("without a handler the legacy covering-index path still runs", async () => {
+  const Database = loadDriver(5000);
+  const db = createDatabase(Database, recordingCluster());
+  let legacy = 0;
+  db.optimize = async () => { legacy += 1; };
+  await 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", async () => {
+  const Database = loadDriver(0);
+  const cluster = recordingCluster();
+  const db = createDatabase(Database, cluster);
+  db.db_config.primary_index = false;
+  db.checkGlobelConnectionObject = () => false;
+  db.collectionExists = async () => false;
+  db.createCollection = async () => {};
+  db.wait = async () => {};
+  let primary = 0;
+  db.createPrimaryIndex = async () => { primary += 1; };
+  await 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\}$/);
+});