spice-couchbase 2.0.48 → 2.0.50

package/build/index.js

@@ -275,11 +275,36 @@ module.exports = class Database {
     })();
   }
 
+  primaryIndexExists(scope_name, col_name) {
+    var _this6 = this;
+
+    return _asyncToGenerator(function* () {
+      try {
+        var response = yield _this6.cluster.query("SELECT RAW name\n         FROM system:indexes\n         WHERE bucket_id = $bucket\n           AND scope_id = $scope\n           AND keyspace_id = $collection\n           AND is_primary = true\n         LIMIT 1", {
+          namedParameters: {
+            bucket: _this6.db_config.bucket,
+            scope: scope_name,
+            collection: col_name
+          },
+          scanConsistency: QueryScanConsistency.RequestPlus
+        });
+        return Array.isArray(response && response.rows) && response.rows.length > 0;
+      } catch (e) {
+        console.log("Primary index lookup failed:", e);
+        return false;
+      }
+    })();
+  }
+
   createPrimaryIndex(scope_name, col_name) {
     var _this6 = this;
 
     return _asyncToGenerator(function* () {
       try {
+        if (yield _this6.primaryIndexExists(scope_name, col_name)) {
+          return;
+        }
+
         var response = yield _this6.query("CREATE PRIMARY INDEX ON default:`".concat(_this6.db_config.bucket, "`.`").concat(scope_name, "`.`").concat(col_name, "`"));
         return response;
       } catch (e) {
@@ -872,4 +897,4 @@ module.exports = class Database {
     })();
   }
 
-};
+};

package/build/utility.js

@@ -181,6 +181,16 @@ function extractGroupByFields(query) {
 
 
 function extractOrderByFields(query) {
+  return extractOrderByIndexFields(query).map(field => field.name);
+}
+/**
+ * Extracts ORDER BY fields with sort direction for index key generation
+ * @param {string} query - The N1QL query
+ * @returns {{name: string, direction: string}[]} - Array of fields with normalized direction
+ */
+
+
+function extractOrderByIndexFields(query) {
   var fields = []; // Find the ORDER BY clause
 
   var orderByMatch = query.match(/\bORDER[\t-\r \xA0\u1680\u2000-\u200A\u2028\u2029\u202F\u205F\u3000\uFEFF]+BY\b([\s\S]+?)(?:\bLIMIT\b|\bOFFSET\b|$)/i);
@@ -194,8 +204,10 @@ function extractOrderByFields(query) {
   var parts = orderByClause.split(",");
 
   for (var part of parts) {
-    var trimmedPart = part.trim(); // Remove ASC/DESC suffix
+    var trimmedPart = part.trim(); // Remove ASC/DESC suffix while preserving DESC for index key generation.
 
+    var directionMatch = trimmedPart.match(/\s+(ASC|DESC)\s*$/i);
+    var direction = directionMatch && directionMatch[1].toUpperCase() === "DESC" ? "DESC" : "";
     var withoutDirection = trimmedPart.replace(/\s+(ASC|DESC)\s*$/i, "").trim(); // Handle collection.field or `collection`.`field` syntax
 
     var fieldMatch = withoutDirection.match(/(?:`?\w+`?\s*\.\s*)?`?(\w+)`?$/);
@@ -204,13 +216,41 @@ function extractOrderByFields(query) {
       var fieldName = fieldMatch[1]; // Skip if it's a keyword or id
 
       if (!["id", "asc", "desc"].includes(fieldName.toLowerCase())) {
-        fields.push(fieldName);
+        fields.push({
+          name: fieldName,
+          direction
+        });
       }
     }
   }
 
   return fields;
 }
+
+function buildOrderDirectionMap(orderByIndexFields) {
+  var directionMap = new Map();
+
+  for (var {
+    name,
+    direction
+  } of orderByIndexFields) {
+    if (direction === "DESC") {
+      directionMap.set(name.toLowerCase(), direction);
+    }
+  }
+
+  return directionMap;
+}
+
+function formatIndexField(field, orderDirectionMap) {
+  var direction = orderDirectionMap.get(field.toLowerCase());
+  return "`".concat(field, "`").concat(direction ? " ".concat(direction) : "");
+}
+
+function formatIndexKey(field, orderDirectionMap) {
+  var direction = orderDirectionMap.get(field.toLowerCase());
+  return "".concat(field).concat(direction ? " ".concat(direction) : "");
+}
 /**
  * Splits SELECT clause by commas, respecting parentheses
  * @param {string} clause - The SELECT clause content
@@ -277,9 +317,11 @@ function buildCoveringIndex(query, options) {
 
   var whereFields = extractWhereFields(query); // Extract fields from GROUP BY clause
 
-  var groupByFields = extractGroupByFields(query); // Extract fields from ORDER BY clause
+  var groupByFields = extractGroupByFields(query); // Extract fields from ORDER BY clause, preserving DESC sort direction
 
-  var orderByFields = extractOrderByFields(query); // Remove 'deleted' from whereFields as it will be added first with INCLUDE MISSING
+  var orderByIndexFields = extractOrderByIndexFields(query);
+  var orderDirectionMap = buildOrderDirectionMap(orderByIndexFields);
+  var orderByFields = orderByIndexFields.map(field => field.name); // Remove 'deleted' from whereFields as it will be added first with INCLUDE MISSING
 
   var filteredWhereFields = whereFields.filter(f => f.toLowerCase() !== "deleted"); // Track fields already added to avoid duplicates
 
@@ -326,10 +368,12 @@ function buildCoveringIndex(query, options) {
   } // Build the field list with deleted INCLUDE MISSING first
 
 
-  var fieldList = ["`deleted` INCLUDE MISSING", ...allFields.map(f => "`".concat(f, "`"))].join(", "); // Generate unique index name based on bucket, scope, collection, and fields
+  var fieldList = ["`deleted` INCLUDE MISSING", ...allFields.map(f => formatIndexField(f, orderDirectionMap))].join(", "); // Generate unique index name based on bucket, scope, collection, and fields
   // This ensures multiple queries covered by the same index get the same hash
 
-  var indexKey = "".concat(bucket, "|").concat(scope, "|").concat(collection, "|").concat(allFields.sort().join(","));
+  var indexFieldsKey = allFields.map(field => formatIndexKey(field, orderDirectionMap)).sort().join(",");
+  var orderFieldsKey = orderByIndexFields.map(field => formatIndexKey(field.name, orderDirectionMap)).join(",");
+  var indexKey = "".concat(bucket, "|").concat(scope, "|").concat(collection, "|fields:").concat(indexFieldsKey, "|order:").concat(orderFieldsKey);
   var hash = generateHash(indexKey);
   var indexName = "adv_covered_".concat(hash); // Build the CREATE INDEX statement
 
@@ -343,5 +387,6 @@ module.exports = {
   extractSelectFields,
   extractGroupByFields,
   extractOrderByFields,
+  extractOrderByIndexFields,
   generateHash
-};
+};

package/build/utility.test.js

@@ -598,6 +598,24 @@ test("same index name for different queries with same fields", () => {
 
   assert.strictEqual(name1, name2);
 });
+test("different index name for different ORDER BY direction", () => {
+  var query1 = "SELECT name FROM users WHERE status = 'active' ORDER BY created_at";
+  var query2 = "SELECT name FROM users WHERE status = 'active' ORDER BY created_at DESC";
+  var result1 = buildCoveringIndex(query1, defaultOptions);
+  var result2 = buildCoveringIndex(query2, defaultOptions);
+  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("different index name for different multiple ORDER BY field order", () => {
+  var query1 = "SELECT email FROM users WHERE status = 'active' ORDER BY last_name ASC, created_at DESC";
+  var query2 = "SELECT email FROM users WHERE status = 'active' ORDER BY created_at DESC, last_name ASC";
+  var result1 = buildCoveringIndex(query1, defaultOptions);
+  var result2 = buildCoveringIndex(query2, defaultOptions);
+  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("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'";
@@ -659,7 +677,7 @@ test("includes ORDER BY fields in index", () => {
   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("`created_at` DESC"));
   assert.ok(result.includes("`name`"));
   assert.ok(result.includes("`email`"));
 });
@@ -681,6 +699,7 @@ test("deduplicates ORDER BY field if already in WHERE", () => {
   var firstCreatedAt = result.indexOf("`created_at`");
   var lastCreatedAt = result.lastIndexOf("`created_at`");
   assert.strictEqual(firstCreatedAt, lastCreatedAt);
+  assert.ok(result.includes("`created_at` DESC"));
 });
 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";
@@ -688,6 +707,7 @@ test("deduplicates ORDER BY field if already in SELECT", () => {
 
   var matches = result.match(/`created_at`/g);
   assert.strictEqual(matches.length, 1);
+  assert.ok(result.includes("`created_at` DESC"));
 });
 test("handles multiple ORDER BY fields", () => {
   var query = "SELECT email FROM users WHERE status = 'active' ORDER BY last_name ASC, first_name ASC";
@@ -701,13 +721,20 @@ test("handles multiple ORDER BY fields", () => {
   assert.ok(lastNameIndex < emailIndex);
   assert.ok(firstNameIndex < emailIndex);
 });
+test("handles mixed ORDER BY directions in index", () => {
+  var query = "SELECT email FROM users WHERE status = 'active' ORDER BY last_name ASC, created_at DESC";
+  var result = buildCoveringIndex(query, defaultOptions);
+  assert.ok(result.includes("`last_name`"));
+  assert.ok(!result.includes("`last_name` ASC"));
+  assert.ok(result.includes("`created_at` DESC"));
+});
 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("`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
@@ -804,4 +831,4 @@ test("field order: WHERE -> GROUP BY -> ORDER BY -> SELECT", () => {
 console.log("\n========================================");
 console.log("Tests: ".concat(passed + failed, " | Passed: ").concat(passed, " | Failed: ").concat(failed));
 console.log("========================================\n");
-process.exit(failed > 0 ? 1 : 0);
+process.exit(failed > 0 ? 1 : 0);

package/package.json

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

package/src/index.js

@@ -250,8 +250,37 @@ module.exports = class Database {
     } catch (e) {}
   }
 
+  async primaryIndexExists(scope_name, col_name) {
+    try {
+      let response = await this.cluster.query(
+        `SELECT RAW name
+         FROM system:indexes
+         WHERE bucket_id = $bucket
+           AND scope_id = $scope
+           AND keyspace_id = $collection
+           AND is_primary = true
+         LIMIT 1`,
+        {
+          namedParameters: {
+            bucket: this.db_config.bucket,
+            scope: scope_name,
+            collection: col_name,
+          },
+          scanConsistency: QueryScanConsistency.RequestPlus,
+        },
+      );
+      return Array.isArray(response?.rows) && response.rows.length > 0;
+    } catch (e) {
+      console.log("Primary index lookup failed:", e);
+      return false;
+    }
+  }
+
   async createPrimaryIndex(scope_name, col_name) {
     try {
+      if (await this.primaryIndexExists(scope_name, col_name)) {
+        return;
+      }
       let response = await this.query(
         `CREATE PRIMARY INDEX ON default:\`${this.db_config.bucket}\`.\`${scope_name}\`.\`${col_name}\``,
       );

package/src/utility.js

@@ -190,6 +190,15 @@ function extractGroupByFields(query) {
  * @returns {string[]} - Array of field names found in ORDER BY clause
  */
 function extractOrderByFields(query) {
+  return extractOrderByIndexFields(query).map((field) => field.name);
+}
+
+/**
+ * Extracts ORDER BY fields with sort direction for index key generation
+ * @param {string} query - The N1QL query
+ * @returns {{name: string, direction: string}[]} - Array of fields with normalized direction
+ */
+function extractOrderByIndexFields(query) {
   const fields = [];
 
   // Find the ORDER BY clause
@@ -208,7 +217,12 @@ function extractOrderByFields(query) {
   for (const part of parts) {
     const trimmedPart = part.trim();
 
-    // Remove ASC/DESC suffix
+    // Remove ASC/DESC suffix while preserving DESC for index key generation.
+    const directionMatch = trimmedPart.match(/\s+(ASC|DESC)\s*$/i);
+    const direction =
+      directionMatch && directionMatch[1].toUpperCase() === "DESC" ?
+        "DESC"
+      : "";
     const withoutDirection = trimmedPart
       .replace(/\s+(ASC|DESC)\s*$/i, "")
       .trim();
@@ -219,7 +233,7 @@ function extractOrderByFields(query) {
       const fieldName = fieldMatch[1];
       // Skip if it's a keyword or id
       if (!["id", "asc", "desc"].includes(fieldName.toLowerCase())) {
-        fields.push(fieldName);
+        fields.push({ name: fieldName, direction });
       }
     }
   }
@@ -227,6 +241,26 @@ function extractOrderByFields(query) {
   return fields;
 }
 
+function buildOrderDirectionMap(orderByIndexFields) {
+  const directionMap = new Map();
+  for (const { name, direction } of orderByIndexFields) {
+    if (direction === "DESC") {
+      directionMap.set(name.toLowerCase(), direction);
+    }
+  }
+  return directionMap;
+}
+
+function formatIndexField(field, orderDirectionMap) {
+  const direction = orderDirectionMap.get(field.toLowerCase());
+  return `\`${field}\`${direction ? ` ${direction}` : ""}`;
+}
+
+function formatIndexKey(field, orderDirectionMap) {
+  const direction = orderDirectionMap.get(field.toLowerCase());
+  return `${field}${direction ? ` ${direction}` : ""}`;
+}
+
 /**
  * Splits SELECT clause by commas, respecting parentheses
  * @param {string} clause - The SELECT clause content
@@ -288,8 +322,10 @@ function buildCoveringIndex(query, options) {
   // Extract fields from GROUP BY clause
   const groupByFields = extractGroupByFields(query);
 
-  // Extract fields from ORDER BY clause
-  const orderByFields = extractOrderByFields(query);
+  // Extract fields from ORDER BY clause, preserving DESC sort direction
+  const orderByIndexFields = extractOrderByIndexFields(query);
+  const orderDirectionMap = buildOrderDirectionMap(orderByIndexFields);
+  const orderByFields = orderByIndexFields.map((field) => field.name);
 
   // Remove 'deleted' from whereFields as it will be added first with INCLUDE MISSING
   const filteredWhereFields = whereFields.filter(
@@ -345,12 +381,19 @@ function buildCoveringIndex(query, options) {
   // Build the field list with deleted INCLUDE MISSING first
   const fieldList = [
     "`deleted` INCLUDE MISSING",
-    ...allFields.map((f) => `\`${f}\``),
+    ...allFields.map((f) => formatIndexField(f, orderDirectionMap)),
   ].join(", ");
 
   // Generate unique index name based on bucket, scope, collection, and fields
   // This ensures multiple queries covered by the same index get the same hash
-  const indexKey = `${bucket}|${scope}|${collection}|${allFields.sort().join(",")}`;
+  const indexFieldsKey = allFields
+    .map((field) => formatIndexKey(field, orderDirectionMap))
+    .sort()
+    .join(",");
+  const orderFieldsKey = orderByIndexFields
+    .map((field) => formatIndexKey(field.name, orderDirectionMap))
+    .join(",");
+  const indexKey = `${bucket}|${scope}|${collection}|fields:${indexFieldsKey}|order:${orderFieldsKey}`;
   const hash = generateHash(indexKey);
   const indexName = `adv_covered_${hash}`;
 
@@ -366,5 +409,6 @@ module.exports = {
   extractSelectFields,
   extractGroupByFields,
   extractOrderByFields,
+  extractOrderByIndexFields,
   generateHash,
 };

package/src/utility.test.js

@@ -722,6 +722,34 @@ test("same index name for different queries with same fields", () => {
   assert.strictEqual(name1, name2);
 });
 
+test("different index name for different ORDER BY direction", () => {
+  const query1 = "SELECT name FROM users WHERE status = 'active' ORDER BY created_at";
+  const query2 = "SELECT name FROM users WHERE status = 'active' ORDER BY created_at DESC";
+
+  const result1 = buildCoveringIndex(query1, defaultOptions);
+  const result2 = buildCoveringIndex(query2, defaultOptions);
+
+  const name1 = result1.match(/CREATE INDEX `(adv_covered_\w+)`/)[1];
+  const name2 = result2.match(/CREATE INDEX `(adv_covered_\w+)`/)[1];
+
+  assert.notStrictEqual(name1, name2);
+});
+
+test("different index name for different multiple ORDER BY field order", () => {
+  const query1 =
+    "SELECT email FROM users WHERE status = 'active' ORDER BY last_name ASC, created_at DESC";
+  const query2 =
+    "SELECT email FROM users WHERE status = 'active' ORDER BY created_at DESC, last_name ASC";
+
+  const result1 = buildCoveringIndex(query1, defaultOptions);
+  const result2 = buildCoveringIndex(query2, defaultOptions);
+
+  const name1 = result1.match(/CREATE INDEX `(adv_covered_\w+)`/)[1];
+  const name2 = result2.match(/CREATE INDEX `(adv_covered_\w+)`/)[1];
+
+  assert.notStrictEqual(name1, name2);
+});
+
 test("different index name for queries with different fields", () => {
   const query1 = "SELECT name FROM users WHERE status = 'active'";
   const query2 = "SELECT email FROM users WHERE type = 'admin'";
@@ -814,7 +842,7 @@ test("includes ORDER BY fields in index", () => {
   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("`created_at` DESC"));
   assert.ok(result.includes("`name`"));
   assert.ok(result.includes("`email`"));
 });
@@ -841,6 +869,7 @@ test("deduplicates ORDER BY field if already in WHERE", () => {
   const firstCreatedAt = result.indexOf("`created_at`");
   const lastCreatedAt = result.lastIndexOf("`created_at`");
   assert.strictEqual(firstCreatedAt, lastCreatedAt);
+  assert.ok(result.includes("`created_at` DESC"));
 });
 
 test("deduplicates ORDER BY field if already in SELECT", () => {
@@ -850,6 +879,7 @@ test("deduplicates ORDER BY field if already in SELECT", () => {
   // created_at should only appear once (in ORDER BY position, before SELECT fields)
   const matches = result.match(/`created_at`/g);
   assert.strictEqual(matches.length, 1);
+  assert.ok(result.includes("`created_at` DESC"));
 });
 
 test("handles multiple ORDER BY fields", () => {
@@ -868,6 +898,15 @@ test("handles multiple ORDER BY fields", () => {
   assert.ok(firstNameIndex < emailIndex);
 });
 
+test("handles mixed ORDER BY directions in index", () => {
+  const query = "SELECT email FROM users WHERE status = 'active' ORDER BY last_name ASC, created_at DESC";
+  const result = buildCoveringIndex(query, defaultOptions);
+
+  assert.ok(result.includes("`last_name`"));
+  assert.ok(!result.includes("`last_name` ASC"));
+  assert.ok(result.includes("`created_at` DESC"));
+});
+
 test("handles realistic query with ORDER BY", () => {
   const query = `SELECT first_name, last_name, email, status 
     FROM users 
@@ -879,7 +918,7 @@ test("handles realistic query with ORDER BY", () => {
   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("`created_at` DESC"));
   assert.ok(result.includes("`first_name`"));
   assert.ok(result.includes("`last_name`"));
   assert.ok(result.includes("`email`"));