spice-couchbase 2.0.44 → 2.0.46

package/build/utility.test.js

@@ -0,0 +1,784 @@
+"use strict";
+
+var assert = require("assert");
+
+var {
+  buildCoveringIndex,
+  extractWhereFields,
+  extractSelectFields,
+  extractGroupByFields,
+  extractOrderByFields,
+  generateHash
+} = require("./utility"); // Test utilities
+
+
+var passed = 0;
+var failed = 0;
+
+function test(name, fn) {
+  try {
+    fn();
+    console.log("\u2713 ".concat(name));
+    passed++;
+  } catch (error) {
+    console.log("\u2717 ".concat(name));
+    console.log("  Error: ".concat(error.message));
+    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");
+  assert.strictEqual(hash.length, 8);
+});
+test("generates consistent hash for same input", () => {
+  var hash1 = generateHash("SELECT * FROM users");
+  var hash2 = generateHash("SELECT * FROM users");
+  assert.strictEqual(hash1, hash2);
+});
+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'";
+  var fields = extractWhereFields(query);
+  assert.ok(arraysEqual(fields, ["status"]));
+});
+test("extracts multiple fields with AND", () => {
+  var query = "SELECT name FROM users WHERE status = 'active' AND type = 'admin'";
+  var fields = extractWhereFields(query);
+  assert.ok(arraysEqual(fields, ["status", "type"]));
+});
+test("extracts fields with comparison operators", () => {
+  var query = "SELECT name FROM users WHERE age > 18 AND score <= 100";
+  var fields = extractWhereFields(query);
+  assert.ok(arraysEqual(fields, ["age", "score"]));
+});
+test("extracts backtick-quoted fields", () => {
+  var query = "SELECT name FROM users WHERE `first_name` = 'John'";
+  var fields = extractWhereFields(query);
+  assert.ok(arraysEqual(fields, ["first_name"]));
+});
+test("extracts fields with IN clause", () => {
+  var query = "SELECT name FROM users WHERE status IN ['active', 'pending']";
+  var fields = extractWhereFields(query);
+  assert.ok(arraysEqual(fields, ["status"]));
+});
+test("extracts fields with LIKE clause", () => {
+  var query = "SELECT name FROM users WHERE name LIKE '%john%'";
+  var fields = extractWhereFields(query);
+  assert.ok(arraysEqual(fields, ["name"]));
+});
+test("extracts fields with IS MISSING", () => {
+  var query = "SELECT name FROM users WHERE deleted IS MISSING";
+  var fields = extractWhereFields(query);
+  assert.ok(arraysEqual(fields, ["deleted"]));
+});
+test("extracts fields with IS NULL", () => {
+  var query = "SELECT name FROM users WHERE email IS NULL";
+  var fields = extractWhereFields(query);
+  assert.ok(arraysEqual(fields, ["email"]));
+});
+test("extracts fields from LOWER function", () => {
+  var query = "SELECT name FROM users WHERE LOWER(email) = 'test@test.com'";
+  var fields = extractWhereFields(query);
+  assert.ok(fields.includes("email"));
+});
+test("returns empty array when no WHERE clause", () => {
+  var query = "SELECT name FROM users";
+  var fields = extractWhereFields(query);
+  assert.ok(arraysEqual(fields, []));
+});
+test("handles deleted check pattern", () => {
+  var query = "SELECT name FROM users WHERE (deleted = false OR deleted IS MISSING) AND status = 'active'";
+  var fields = extractWhereFields(query);
+  assert.ok(fields.includes("deleted"));
+  assert.ok(fields.includes("status"));
+});
+test("stops at ORDER BY", () => {
+  var query = "SELECT name FROM users WHERE status = 'active' ORDER BY created_at";
+  var fields = extractWhereFields(query);
+  assert.ok(arraysEqual(fields, ["status"]));
+  assert.ok(!fields.includes("created_at"));
+});
+test("stops at LIMIT", () => {
+  var query = "SELECT name FROM users WHERE status = 'active' LIMIT 10";
+  var fields = extractWhereFields(query);
+  assert.ok(arraysEqual(fields, ["status"]));
+});
+test("stops at OFFSET", () => {
+  var query = "SELECT name FROM users WHERE status = 'active' OFFSET 20";
+  var fields = extractWhereFields(query);
+  assert.ok(arraysEqual(fields, ["status"]));
+});
+test("handles type field (legacy pattern)", () => {
+  var query = "SELECT name FROM bucket WHERE type = 'user' AND status = 'active'";
+  var fields = extractWhereFields(query);
+  assert.ok(fields.includes("type"));
+  assert.ok(fields.includes("status"));
+});
+test("handles not equals operator !=", () => {
+  var query = "SELECT name FROM users WHERE status != 'deleted'";
+  var fields = extractWhereFields(query);
+  assert.ok(arraysEqual(fields, ["status"]));
+});
+test("handles not equals operator <>", () => {
+  var query = "SELECT name FROM users WHERE status <> 'deleted'";
+  var fields = extractWhereFields(query);
+  assert.ok(arraysEqual(fields, ["status"]));
+});
+test("handles BETWEEN clause", () => {
+  var query = "SELECT name FROM users WHERE age BETWEEN 18 AND 65";
+  var fields = extractWhereFields(query);
+  assert.ok(fields.includes("age"));
+});
+test("handles OR conditions", () => {
+  var query = "SELECT name FROM users WHERE status = 'active' OR status = 'pending'";
+  var fields = extractWhereFields(query);
+  assert.ok(fields.includes("status"));
+});
+test("handles nested parentheses", () => {
+  var query = "SELECT name FROM users WHERE ((status = 'active') AND (type = 'admin'))";
+  var fields = extractWhereFields(query);
+  assert.ok(fields.includes("status"));
+  assert.ok(fields.includes("type"));
+});
+test("handles complex deleted pattern with additional conditions", () => {
+  var query = "SELECT first_name, last_name FROM users \n    WHERE (deleted = false OR deleted IS MISSING) \n    AND status = 'active' \n    AND type = 'user'\n    ORDER BY created_at";
+  var fields = extractWhereFields(query);
+  assert.ok(fields.includes("deleted"));
+  assert.ok(fields.includes("status"));
+  assert.ok(fields.includes("type"));
+  assert.ok(!fields.includes("created_at")); // ORDER BY field should not be included
+});
+test("stops at GROUP BY", () => {
+  var query = "SELECT COUNT(status) FROM users WHERE type = 'admin' GROUP BY status";
+  var fields = extractWhereFields(query);
+  assert.ok(arraysEqual(fields, ["type"]));
+});
+test("stops at HAVING", () => {
+  var query = "SELECT status FROM users WHERE type = 'admin' GROUP BY status HAVING COUNT(*) > 5";
+  var fields = extractWhereFields(query);
+  assert.ok(arraysEqual(fields, ["type"]));
+});
+test("handles ANY array operator", () => {
+  var query = "SELECT name FROM users WHERE ANY tag IN tags SATISFIES tag = 'vip' END";
+  var fields = extractWhereFields(query);
+  assert.ok(fields.includes("tags"));
+});
+test("handles EVERY array operator", () => {
+  var query = "SELECT name FROM users WHERE EVERY score IN scores SATISFIES score > 50 END";
+  var fields = extractWhereFields(query);
+  assert.ok(fields.includes("scores"));
+});
+test("handles ANY with additional conditions", () => {
+  var query = "SELECT name FROM users WHERE status = 'active' AND ANY tag IN tags SATISFIES tag = 'premium' END";
+  var fields = extractWhereFields(query);
+  assert.ok(fields.includes("status"));
+  assert.ok(fields.includes("tags"));
+});
+test("handles EVERY with additional conditions", () => {
+  var query = "SELECT name FROM users WHERE type = 'user' AND EVERY item IN items SATISFIES item.quantity > 0 END";
+  var fields = extractWhereFields(query);
+  assert.ok(fields.includes("type"));
+  assert.ok(fields.includes("items"));
+});
+test("handles ANY with backtick-quoted array field", () => {
+  var query = "SELECT name FROM users WHERE ANY t IN `user_tags` SATISFIES t = 'admin' END";
+  var fields = extractWhereFields(query);
+  assert.ok(fields.includes("user_tags"));
+});
+test("handles multiple ANY clauses", () => {
+  var query = "SELECT name FROM users WHERE ANY t IN tags SATISFIES t = 'vip' END AND ANY r IN roles SATISFIES r = 'admin' END";
+  var fields = extractWhereFields(query);
+  assert.ok(fields.includes("tags"));
+  assert.ok(fields.includes("roles"));
+});
+test("handles ANY and EVERY together", () => {
+  var query = "SELECT name FROM users WHERE ANY t IN tags SATISFIES t = 'active' END AND EVERY s IN scores SATISFIES s >= 0 END";
+  var fields = extractWhereFields(query);
+  assert.ok(fields.includes("tags"));
+  assert.ok(fields.includes("scores"));
+});
+test("handles complex ANY with deleted pattern", () => {
+  var query = "SELECT name, email FROM users \n    WHERE (deleted = false OR deleted IS MISSING) \n    AND status = 'active' \n    AND ANY tag IN tags SATISFIES tag = 'premium' END";
+  var fields = extractWhereFields(query);
+  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";
+  var fields = extractSelectFields(query);
+  assert.ok(arraysEqual(fields, ["name"]));
+});
+test("extracts multiple fields", () => {
+  var query = "SELECT name, email, status FROM users";
+  var fields = extractSelectFields(query);
+  assert.ok(arraysEqual(fields, ["name", "email", "status"]));
+});
+test("returns null for SELECT *", () => {
+  var query = "SELECT * FROM users";
+  var fields = extractSelectFields(query);
+  assert.strictEqual(fields, null);
+});
+test("returns null for SELECT collection.*", () => {
+  var query = "SELECT users.* FROM users";
+  var fields = extractSelectFields(query);
+  assert.strictEqual(fields, null);
+});
+test("returns null for SELECT (bucket).* pattern", () => {
+  var query = "SELECT (`users`).*, META(`users`).id AS id FROM users";
+  var fields = extractSelectFields(query);
+  assert.strictEqual(fields, null);
+});
+test("extracts backtick-quoted fields", () => {
+  var query = "SELECT `first_name`, `last_name` FROM users";
+  var fields = extractSelectFields(query);
+  assert.ok(arraysEqual(fields, ["first_name", "last_name"]));
+});
+test("handles AS alias", () => {
+  var query = "SELECT first_name AS fname, last_name AS lname FROM users";
+  var fields = extractSelectFields(query);
+  assert.ok(arraysEqual(fields, ["first_name", "last_name"]));
+});
+test("skips META().id", () => {
+  var query = "SELECT name, META(users).id AS id FROM users";
+  var fields = extractSelectFields(query);
+  assert.ok(arraysEqual(fields, ["name"]));
+});
+test("extracts field from aggregate function", () => {
+  var query = "SELECT COUNT(status) FROM users";
+  var fields = extractSelectFields(query);
+  assert.ok(arraysEqual(fields, ["status"]));
+});
+test("handles collection.field syntax", () => {
+  var query = "SELECT users.name, users.email FROM users";
+  var fields = extractSelectFields(query);
+  assert.ok(arraysEqual(fields, ["name", "email"]));
+});
+test("returns null when no SELECT clause found", () => {
+  var query = "INVALID QUERY";
+  var fields = extractSelectFields(query);
+  assert.strictEqual(fields, null);
+});
+test("handles multiple aggregate functions", () => {
+  var query = "SELECT COUNT(status), SUM(amount), AVG(score) FROM users";
+  var fields = extractSelectFields(query);
+  assert.ok(fields.includes("status"));
+  assert.ok(fields.includes("amount"));
+  assert.ok(fields.includes("score"));
+});
+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
+
+  assert.ok(fields.length >= 0); // At minimum should not crash
+});
+test("handles query with JOIN", () => {
+  var query = "SELECT users.name, orders.total FROM users JOIN orders ON users.id = orders.user_id";
+  var fields = extractSelectFields(query);
+  assert.ok(fields.includes("name"));
+  assert.ok(fields.includes("total"));
+});
+test("handles DISTINCT keyword", () => {
+  var query = "SELECT DISTINCT status, type FROM users";
+  var fields = extractSelectFields(query);
+  assert.ok(fields.includes("status"));
+  assert.ok(fields.includes("type"));
+});
+test("handles query generated by search function pattern", () => {
+  // Pattern: SELECT columns FROM `collection` WHERE conditions ORDER BY ... LIMIT ... OFFSET ...
+  var query = "SELECT first_name, last_name, email, META(`users`).id AS id FROM `users` WHERE type = 'user' AND status = 'active' ORDER BY created_at LIMIT 100 OFFSET 0";
+  var fields = extractSelectFields(query);
+  assert.ok(fields.includes("first_name"));
+  assert.ok(fields.includes("last_name"));
+  assert.ok(fields.includes("email"));
+  assert.ok(!fields.includes("id")); // META().id should be skipped
+});
+test("handles backtick collection prefix", () => {
+  var query = "SELECT `users`.`first_name`, `users`.`last_name` FROM `users`";
+  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";
+  var fields = extractGroupByFields(query);
+  assert.ok(arraysEqual(fields, ["status"]));
+});
+test("extracts multiple GROUP BY fields", () => {
+  var query = "SELECT status, type, COUNT(*) FROM users GROUP BY status, type";
+  var fields = extractGroupByFields(query);
+  assert.ok(arraysEqual(fields, ["status", "type"]));
+});
+test("extracts GROUP BY with backtick-quoted fields", () => {
+  var query = "SELECT `status`, COUNT(*) FROM users GROUP BY `status`";
+  var fields = extractGroupByFields(query);
+  assert.ok(arraysEqual(fields, ["status"]));
+});
+test("extracts GROUP BY with collection prefix", () => {
+  var query = "SELECT status, COUNT(*) FROM users GROUP BY users.status";
+  var fields = extractGroupByFields(query);
+  assert.ok(arraysEqual(fields, ["status"]));
+});
+test("extracts GROUP BY with backtick collection prefix", () => {
+  var query = "SELECT status, COUNT(*) FROM users GROUP BY `users`.`status`";
+  var fields = extractGroupByFields(query);
+  assert.ok(arraysEqual(fields, ["status"]));
+});
+test("returns empty array when no GROUP BY clause", () => {
+  var query = "SELECT name FROM users WHERE status = 'active'";
+  var fields = extractGroupByFields(query);
+  assert.ok(arraysEqual(fields, []));
+});
+test("stops at HAVING", () => {
+  var query = "SELECT status, COUNT(*) as cnt FROM users GROUP BY status HAVING COUNT(*) > 5";
+  var fields = extractGroupByFields(query);
+  assert.ok(arraysEqual(fields, ["status"]));
+});
+test("stops at ORDER BY", () => {
+  var query = "SELECT status, COUNT(*) FROM users GROUP BY status ORDER BY status";
+  var fields = extractGroupByFields(query);
+  assert.ok(arraysEqual(fields, ["status"]));
+});
+test("stops at LIMIT", () => {
+  var query = "SELECT status, COUNT(*) FROM users GROUP BY status LIMIT 10";
+  var fields = extractGroupByFields(query);
+  assert.ok(arraysEqual(fields, ["status"]));
+});
+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";
+  var fields = extractOrderByFields(query);
+  assert.ok(arraysEqual(fields, ["created_at"]));
+});
+test("extracts ORDER BY field with ASC", () => {
+  var query = "SELECT name FROM users ORDER BY created_at ASC";
+  var fields = extractOrderByFields(query);
+  assert.ok(arraysEqual(fields, ["created_at"]));
+});
+test("extracts ORDER BY field with DESC", () => {
+  var query = "SELECT name FROM users ORDER BY created_at DESC";
+  var fields = extractOrderByFields(query);
+  assert.ok(arraysEqual(fields, ["created_at"]));
+});
+test("extracts multiple ORDER BY fields", () => {
+  var query = "SELECT name FROM users ORDER BY last_name ASC, first_name ASC";
+  var fields = extractOrderByFields(query);
+  assert.ok(arraysEqual(fields, ["last_name", "first_name"]));
+});
+test("extracts ORDER BY with backtick-quoted fields", () => {
+  var query = "SELECT name FROM users ORDER BY `created_at` DESC";
+  var fields = extractOrderByFields(query);
+  assert.ok(arraysEqual(fields, ["created_at"]));
+});
+test("extracts ORDER BY with collection prefix", () => {
+  var query = "SELECT name FROM users ORDER BY users.created_at DESC";
+  var fields = extractOrderByFields(query);
+  assert.ok(arraysEqual(fields, ["created_at"]));
+});
+test("extracts ORDER BY with backtick collection prefix", () => {
+  var query = "SELECT name FROM users ORDER BY `users`.`created_at` DESC";
+  var fields = extractOrderByFields(query);
+  assert.ok(arraysEqual(fields, ["created_at"]));
+});
+test("returns empty array when no ORDER BY clause", () => {
+  var query = "SELECT name FROM users WHERE status = 'active'";
+  var fields = extractOrderByFields(query);
+  assert.ok(arraysEqual(fields, []));
+});
+test("stops at LIMIT", () => {
+  var query = "SELECT name FROM users ORDER BY created_at DESC LIMIT 10";
+  var fields = extractOrderByFields(query);
+  assert.ok(arraysEqual(fields, ["created_at"]));
+});
+test("stops at OFFSET", () => {
+  var query = "SELECT name FROM users ORDER BY created_at DESC OFFSET 20";
+  var fields = extractOrderByFields(query);
+  assert.ok(arraysEqual(fields, ["created_at"]));
+});
+test("handles ORDER BY with LIMIT and OFFSET", () => {
+  var query = "SELECT name FROM users ORDER BY created_at DESC LIMIT 10 OFFSET 20";
+  var fields = extractOrderByFields(query);
+  assert.ok(arraysEqual(fields, ["created_at"]));
+});
+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",
+  scope: "test-scope",
+  collection: "users"
+};
+test("builds basic covering index", () => {
+  var query = "SELECT name, email FROM users WHERE status = 'active'";
+  var result = buildCoveringIndex(query, defaultOptions);
+  assert.ok(result !== null);
+  assert.ok(result.startsWith("CREATE INDEX"));
+  assert.ok(result.includes("`deleted` INCLUDE MISSING"));
+  assert.ok(result.includes("`status`"));
+  assert.ok(result.includes("`name`"));
+  assert.ok(result.includes("`email`"));
+  assert.ok(result.includes("`saturn`.`test-scope`.`users`"));
+});
+test("deleted field comes first", () => {
+  var query = "SELECT name FROM users WHERE status = 'active'";
+  var result = buildCoveringIndex(query, defaultOptions);
+  var deletedIndex = result.indexOf("`deleted` INCLUDE MISSING");
+  var statusIndex = result.indexOf("`status`");
+  assert.ok(deletedIndex < statusIndex);
+});
+test("WHERE fields come before SELECT fields", () => {
+  var query = "SELECT email FROM users WHERE status = 'active'";
+  var result = buildCoveringIndex(query, defaultOptions);
+  var statusIndex = result.indexOf("`status`");
+  var emailIndex = result.indexOf("`email`");
+  assert.ok(statusIndex < emailIndex);
+});
+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 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 matches = result.match(/`deleted`/g);
+  assert.strictEqual(matches.length, 1);
+  assert.ok(result.includes("`deleted` INCLUDE MISSING"));
+});
+test("returns null for SELECT * query", () => {
+  var query = "SELECT * FROM users WHERE status = 'active'";
+  var result = buildCoveringIndex(query, defaultOptions);
+  assert.strictEqual(result, null);
+});
+test("returns null when missing bucket option", () => {
+  var query = "SELECT name FROM users WHERE status = 'active'";
+  var result = buildCoveringIndex(query, {
+    scope: "test",
+    collection: "users"
+  });
+  assert.strictEqual(result, null);
+});
+test("returns null when missing scope option", () => {
+  var query = "SELECT name FROM users WHERE status = 'active'";
+  var result = buildCoveringIndex(query, {
+    bucket: "test",
+    collection: "users"
+  });
+  assert.strictEqual(result, null);
+});
+test("returns null when missing collection option", () => {
+  var query = "SELECT name FROM users WHERE status = 'active'";
+  var result = buildCoveringIndex(query, {
+    bucket: "test",
+    scope: "scope"
+  });
+  assert.strictEqual(result, null);
+});
+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 name1 = result1.match(/CREATE INDEX `(adv_covered_\w+)`/)[1];
+  var name2 = result2.match(/CREATE INDEX `(adv_covered_\w+)`/)[1];
+  assert.notStrictEqual(name1, name2);
+});
+test("handles complex query with multiple conditions", () => {
+  var query = "\n    SELECT first_name, last_name, email, status \n    FROM users \n    WHERE (deleted = false OR deleted IS MISSING) \n      AND status = 'active' \n      AND created_at > '2024-01-01'\n    ORDER BY created_at\n    LIMIT 100\n  ";
+  var result = buildCoveringIndex(query, defaultOptions);
+  assert.ok(result !== null);
+  assert.ok(result.includes("`deleted` INCLUDE MISSING"));
+  assert.ok(result.includes("`status`"));
+  assert.ok(result.includes("`created_at`"));
+  assert.ok(result.includes("`first_name`"));
+  assert.ok(result.includes("`last_name`"));
+  assert.ok(result.includes("`email`"));
+});
+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
+
+  assert.strictEqual(result, null);
+});
+test("handles query with type field (legacy pattern)", () => {
+  var query = "SELECT name, email FROM bucket WHERE type = 'user' AND status = 'active'";
+  var result = buildCoveringIndex(query, defaultOptions);
+  assert.ok(result !== null);
+  assert.ok(result.includes("`type`"));
+  assert.ok(result.includes("`status`"));
+  assert.ok(result.includes("`name`"));
+  assert.ok(result.includes("`email`"));
+});
+test("handles realistic search query pattern", () => {
+  var query = "SELECT first_name, last_name, email, status, META(`users`).id AS id \n    FROM `users` \n    WHERE (deleted = false OR deleted IS MISSING) AND status = 'active' \n    ORDER BY created_at DESC \n    LIMIT 50 OFFSET 0";
+  var result = buildCoveringIndex(query, defaultOptions);
+  assert.ok(result !== null);
+  assert.ok(result.includes("`deleted` INCLUDE MISSING"));
+  assert.ok(result.includes("`status`"));
+  assert.ok(result.includes("`first_name`"));
+  assert.ok(result.includes("`last_name`"));
+  assert.ok(result.includes("`email`"));
+});
+test("handles query with BETWEEN in WHERE", () => {
+  var query = "SELECT name FROM users WHERE age BETWEEN 18 AND 65";
+  var result = buildCoveringIndex(query, defaultOptions);
+  assert.ok(result !== null);
+  assert.ok(result.includes("`age`"));
+  assert.ok(result.includes("`name`"));
+});
+test("handles query with multiple OR conditions", () => {
+  var query = "SELECT name FROM users WHERE status = 'active' OR status = 'pending' OR status = 'review'";
+  var result = buildCoveringIndex(query, defaultOptions);
+  assert.ok(result !== null);
+  assert.ok(result.includes("`status`"));
+  assert.ok(result.includes("`name`"));
+});
+test("consistent index name for same query", () => {
+  var query = "SELECT name FROM users WHERE status = 'active'";
+  var result1 = buildCoveringIndex(query, defaultOptions);
+  var result2 = buildCoveringIndex(query, defaultOptions);
+  assert.strictEqual(result1, result2);
+});
+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
+
+  assert.ok(result.startsWith("CREATE INDEX `adv_covered_"));
+  assert.ok(result.includes("`deleted` INCLUDE MISSING"));
+  assert.ok(result.includes("`created_at`"));
+  assert.ok(result.includes("`first_name`"));
+  assert.ok(result.includes("`middle_name`"));
+  assert.ok(result.includes("`last_name`"));
+  assert.ok(result.includes("`status`"));
+  assert.ok(result.includes("`constituency`"));
+  assert.ok(result.includes("`division`"));
+  assert.ok(result.includes("`description`"));
+});
+test("handles query with ANY array operator", () => {
+  var query = "SELECT name, email FROM users \n    WHERE (deleted = false OR deleted IS MISSING) \n    AND ANY tag IN tags SATISFIES tag = 'premium' END";
+  var result = buildCoveringIndex(query, defaultOptions);
+  assert.ok(result !== null);
+  assert.ok(result.includes("`deleted` INCLUDE MISSING"));
+  assert.ok(result.includes("`tags`"));
+  assert.ok(result.includes("`name`"));
+  assert.ok(result.includes("`email`"));
+});
+test("handles query with EVERY array operator", () => {
+  var query = "SELECT name FROM users \n    WHERE status = 'active' \n    AND EVERY score IN scores SATISFIES score > 0 END";
+  var result = buildCoveringIndex(query, defaultOptions);
+  assert.ok(result !== null);
+  assert.ok(result.includes("`status`"));
+  assert.ok(result.includes("`scores`"));
+  assert.ok(result.includes("`name`"));
+});
+test("handles complex query with multiple ANY/EVERY", () => {
+  var query = "SELECT name, email, status FROM users \n    WHERE (deleted = false OR deleted IS MISSING) \n    AND type = 'user'\n    AND ANY tag IN tags SATISFIES tag = 'active' END \n    AND EVERY perm IN permissions SATISFIES perm.level >= 1 END";
+  var result = buildCoveringIndex(query, defaultOptions);
+  assert.ok(result !== null);
+  assert.ok(result.includes("`deleted` INCLUDE MISSING"));
+  assert.ok(result.includes("`type`"));
+  assert.ok(result.includes("`tags`"));
+  assert.ok(result.includes("`permissions`"));
+  assert.ok(result.includes("`name`"));
+  assert.ok(result.includes("`email`"));
+  assert.ok(result.includes("`status`"));
+});
+test("includes ORDER BY fields in index", () => {
+  var query = "SELECT name, email FROM users WHERE status = 'active' ORDER BY created_at DESC";
+  var result = buildCoveringIndex(query, defaultOptions);
+  assert.ok(result !== null);
+  assert.ok(result.includes("`deleted` INCLUDE MISSING"));
+  assert.ok(result.includes("`status`"));
+  assert.ok(result.includes("`created_at`"));
+  assert.ok(result.includes("`name`"));
+  assert.ok(result.includes("`email`"));
+});
+test("ORDER BY fields come after WHERE fields", () => {
+  var query = "SELECT email FROM users WHERE status = 'active' ORDER BY created_at";
+  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)
+
+  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 firstCreatedAt = result.indexOf("`created_at`");
+  var lastCreatedAt = result.lastIndexOf("`created_at`");
+  assert.strictEqual(firstCreatedAt, lastCreatedAt);
+});
+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 matches = result.match(/`created_at`/g);
+  assert.strictEqual(matches.length, 1);
+});
+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
+
+  var lastNameIndex = result.indexOf("`last_name`");
+  var firstNameIndex = result.indexOf("`first_name`");
+  var emailIndex = result.indexOf("`email`");
+  assert.ok(lastNameIndex < emailIndex);
+  assert.ok(firstNameIndex < emailIndex);
+});
+test("handles realistic query with ORDER BY", () => {
+  var query = "SELECT first_name, last_name, email, status \n    FROM users \n    WHERE (deleted = false OR deleted IS MISSING) AND status = 'active' \n    ORDER BY created_at DESC \n    LIMIT 50 OFFSET 0";
+  var result = buildCoveringIndex(query, defaultOptions);
+  assert.ok(result !== null);
+  assert.ok(result.includes("`deleted` INCLUDE MISSING"));
+  assert.ok(result.includes("`status`"));
+  assert.ok(result.includes("`created_at`"));
+  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
+
+  var statusIndex = result.indexOf("`status`");
+  var createdAtIndex = result.indexOf("`created_at`");
+  var firstNameIndex = result.indexOf("`first_name`");
+  assert.ok(statusIndex < createdAtIndex);
+  assert.ok(createdAtIndex < firstNameIndex);
+});
+test("includes GROUP BY fields in index", () => {
+  var query = "SELECT status, COUNT(name) as cnt FROM users WHERE type = 'user' GROUP BY status";
+  var result = buildCoveringIndex(query, defaultOptions);
+  assert.ok(result !== null);
+  assert.ok(result.includes("`deleted` INCLUDE MISSING"));
+  assert.ok(result.includes("`type`"));
+  assert.ok(result.includes("`status`"));
+  assert.ok(result.includes("`name`"));
+});
+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)
+
+  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 matches = result.match(/`status`/g);
+  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 matches = result.match(/`status`/g);
+  assert.strictEqual(matches.length, 1);
+});
+test("handles multiple GROUP BY fields", () => {
+  var query = "SELECT status, type, COUNT(name) FROM users WHERE category = 'A' GROUP BY status, type";
+  var result = buildCoveringIndex(query, defaultOptions);
+  assert.ok(result.includes("`category`"));
+  assert.ok(result.includes("`status`"));
+  assert.ok(result.includes("`type`"));
+  assert.ok(result.includes("`name`"));
+});
+test("handles GROUP BY with HAVING and ORDER BY", () => {
+  var query = "SELECT status, COUNT(name) as cnt \n    FROM users \n    WHERE type = 'user' \n    GROUP BY status \n    HAVING COUNT(name) > 5 \n    ORDER BY cnt DESC";
+  var result = buildCoveringIndex(query, defaultOptions);
+  assert.ok(result !== null);
+  assert.ok(result.includes("`type`"));
+  assert.ok(result.includes("`status`"));
+  assert.ok(result.includes("`name`"));
+});
+test("handles realistic GROUP BY query", () => {
+  var query = "SELECT status, COUNT(first_name) as user_count \n    FROM users \n    WHERE (deleted = false OR deleted IS MISSING) AND type = 'user' \n    GROUP BY status \n    ORDER BY user_count DESC \n    LIMIT 10";
+  var result = buildCoveringIndex(query, defaultOptions);
+  assert.ok(result !== null);
+  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)
+
+  var typeIndex = result.indexOf("`type`");
+  var statusIndex = result.indexOf("`status`");
+  var firstNameIndex = result.indexOf("`first_name`");
+  assert.ok(typeIndex < statusIndex);
+  assert.ok(statusIndex < firstNameIndex);
+});
+test("field order: WHERE -> GROUP BY -> ORDER BY -> SELECT", () => {
+  var query = "SELECT email \n    FROM users \n    WHERE type = 'user' \n    GROUP BY status \n    ORDER BY created_at";
+  var result = buildCoveringIndex(query, defaultOptions);
+  var typeIndex = result.indexOf("`type`");
+  var statusIndex = result.indexOf("`status`");
+  var createdAtIndex = result.indexOf("`created_at`");
+  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
+}); // ============================================
+// Summary
+// ============================================
+
+console.log("\n========================================");
+console.log("Tests: ".concat(passed + failed, " | Passed: ").concat(passed, " | Failed: ").concat(failed));
+console.log("========================================\n");
+process.exit(failed > 0 ? 1 : 0);