spice-couchbase 2.0.47 → 2.0.49

package/build/index.js

@@ -115,10 +115,16 @@ module.exports = class Database {
     var _this = this;
 
     return _asyncToGenerator(function* () {
-      var cluster = yield couchbase.connect(config.nodes, {
+      var connectOptions = {
         username: config.username,
         password: config.password
-      });
+      };
+
+      if (config.configProfile) {
+        connectOptions.configProfile = config.configProfile;
+      }
+
+      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";

package/build/index.multi_get.test.js

@@ -0,0 +1,327 @@
+"use strict";
+
+function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) { try { var info = gen[key](arg); var value = info.value; } catch (error) { reject(error); return; } if (info.done) { resolve(value); } else { Promise.resolve(value).then(_next, _throw); } }
+
+function _asyncToGenerator(fn) { return function () { var self = this, args = arguments; return new Promise(function (resolve, reject) { var gen = fn.apply(self, args); function _next(value) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value); } function _throw(err) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err); } _next(undefined); }); }; }
+
+var assert = require("assert");
+
+var Database = require("./index");
+
+var passed = 0;
+var failed = 0;
+
+function createDb(_ref) {
+  var {
+    lookupIn,
+    get
+  } = _ref;
+  var db = Object.create(Database.prototype);
+  var collection = {
+    lookupIn,
+    get
+  };
+  db.use_bucket_name = false;
+  db.collection = collection;
+  db.connection = collection;
+  return db;
+}
+
+function test(_x, _x2) {
+  return _test.apply(this, arguments);
+}
+
+function _test() {
+  _test = _asyncToGenerator(function* (name, fn) {
+    try {
+      yield fn();
+      console.log("\u2713 ".concat(name));
+      passed++;
+    } catch (error) {
+      console.log("\u2717 ".concat(name));
+      console.log("  Error: ".concat(error.message));
+      failed++;
+    }
+  });
+  return _test.apply(this, arguments);
+}
+
+function run() {
+  return _run.apply(this, arguments);
+}
+
+function _run() {
+  _run = _asyncToGenerator(function* () {
+    console.log("\n--- multi_get tests ---");
+    yield test("lookupIn success with dotted object path does not fallback to get",
+    /*#__PURE__*/
+    _asyncToGenerator(function* () {
+      var getCalls = 0;
+      var db = createDb({
+        lookupIn: function () {
+          var _lookupIn = _asyncToGenerator(function* () {
+            return {
+              content: [{
+                value: "Alice",
+                error: null
+              }]
+            };
+          });
+
+          function lookupIn() {
+            return _lookupIn.apply(this, arguments);
+          }
+
+          return lookupIn;
+        }(),
+        get: function () {
+          var _get = _asyncToGenerator(function* () {
+            getCalls++;
+            return {
+              content: {
+                profile: {
+                  name: "Alice"
+                }
+              }
+            };
+          });
+
+          function get() {
+            return _get.apply(this, arguments);
+          }
+
+          return get;
+        }()
+      });
+      var result = yield db.multi_get(["doc-1"], {
+        columns: ["profile.name"]
+      });
+      assert.deepStrictEqual(result, [{
+        id: "doc-1",
+        "profile.name": "Alice"
+      }]);
+      assert.strictEqual(getCalls, 0);
+    }));
+    yield test("array-mapped dotted path falls back and returns mapped array values",
+    /*#__PURE__*/
+    _asyncToGenerator(function* () {
+      var db = createDb({
+        lookupIn: function () {
+          var _lookupIn2 = _asyncToGenerator(function* () {
+            return {
+              content: [{
+                value: undefined,
+                error: new Error("path mismatch")
+              }]
+            };
+          });
+
+          function lookupIn() {
+            return _lookupIn2.apply(this, arguments);
+          }
+
+          return lookupIn;
+        }(),
+        get: function () {
+          var _get2 = _asyncToGenerator(function* () {
+            return {
+              content: {
+                tags: [{
+                  name: "vip"
+                }, {
+                  name: "beta"
+                }]
+              }
+            };
+          });
+
+          function get() {
+            return _get2.apply(this, arguments);
+          }
+
+          return get;
+        }()
+      });
+      var result = yield db.multi_get(["doc-1"], {
+        columns: ["tags.name"]
+      });
+      assert.deepStrictEqual(result, [{
+        id: "doc-1",
+        "tags.name": ["vip", "beta"]
+      }]);
+    }));
+    yield test("missing dotted fields return typed empties (object and array)",
+    /*#__PURE__*/
+    _asyncToGenerator(function* () {
+      var db = createDb({
+        lookupIn: function () {
+          var _lookupIn3 = _asyncToGenerator(function* () {
+            return {
+              content: [{
+                value: undefined,
+                error: new Error("path mismatch")
+              }]
+            };
+          });
+
+          function lookupIn() {
+            return _lookupIn3.apply(this, arguments);
+          }
+
+          return lookupIn;
+        }(),
+        get: function () {
+          var _get3 = _asyncToGenerator(function* () {
+            return {
+              content: {
+                profile: {},
+                tags: []
+              }
+            };
+          });
+
+          function get() {
+            return _get3.apply(this, arguments);
+          }
+
+          return get;
+        }()
+      });
+      var result = yield db.multi_get(["doc-1"], {
+        columns: ["profile.details", "tags.name"]
+      });
+      assert.deepStrictEqual(result, [{
+        id: "doc-1",
+        "profile.details": {},
+        "tags.name": []
+      }]);
+    }));
+    yield test("mixed key outcomes keep order and omit missing docs",
+    /*#__PURE__*/
+    _asyncToGenerator(function* () {
+      var db = createDb({
+        lookupIn: function () {
+          var _lookupIn4 = _asyncToGenerator(function* (key) {
+            if (key === "a") {
+              return {
+                content: [{
+                  value: "Alice",
+                  error: null
+                }]
+              };
+            }
+
+            if (key === "b") {
+              return {
+                content: [{
+                  value: undefined,
+                  error: new Error("path mismatch")
+                }]
+              };
+            }
+
+            throw new Error("not found");
+          });
+
+          function lookupIn(_x3) {
+            return _lookupIn4.apply(this, arguments);
+          }
+
+          return lookupIn;
+        }(),
+        get: function () {
+          var _get4 = _asyncToGenerator(function* (key) {
+            if (key === "b") {
+              return {
+                content: {
+                  tags: [{
+                    name: "vip"
+                  }, {
+                    name: "beta"
+                  }]
+                }
+              };
+            }
+
+            throw new Error("not found");
+          });
+
+          function get(_x4) {
+            return _get4.apply(this, arguments);
+          }
+
+          return get;
+        }()
+      });
+      var result = yield db.multi_get(["a", "b", "c"], {
+        columns: ["tags.name"]
+      });
+      assert.deepStrictEqual(result, [{
+        id: "a",
+        "tags.name": "Alice"
+      }, {
+        id: "b",
+        "tags.name": ["vip", "beta"]
+      }]);
+    }));
+    yield test("non-column multi_get behavior remains unchanged",
+    /*#__PURE__*/
+    _asyncToGenerator(function* () {
+      var db = createDb({
+        lookupIn: function () {
+          var _lookupIn5 = _asyncToGenerator(function* () {
+            throw new Error("should not be called");
+          });
+
+          function lookupIn() {
+            return _lookupIn5.apply(this, arguments);
+          }
+
+          return lookupIn;
+        }(),
+        get: function () {
+          var _get5 = _asyncToGenerator(function* (key) {
+            if (key === "missing") {
+              throw new Error("not found");
+            }
+
+            return {
+              value: {
+                type: "user",
+                name: key.toUpperCase()
+              }
+            };
+          });
+
+          function get(_x5) {
+            return _get5.apply(this, arguments);
+          }
+
+          return get;
+        }()
+      });
+      var result = yield db.multi_get(["a", "missing", "b"], {
+        keep_type: false
+      });
+      assert.deepStrictEqual(result, [{
+        name: "A",
+        id: "a"
+      }, {
+        name: "B",
+        id: "b"
+      }]);
+    }));
+    console.log("\nPassed: ".concat(passed));
+    console.log("Failed: ".concat(failed));
+
+    if (failed > 0) {
+      process.exitCode = 1;
+    }
+  });
+  return _run.apply(this, arguments);
+}
+
+run().catch(error => {
+  console.error(error);
+  process.exit(1);
+});

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.47",
+  "version": "2.0.49",
   "description": "",
   "main": "build/index.js",
   "scripts": {

package/src/index.js

@@ -113,10 +113,15 @@ module.exports = class Database {
   }
 
   async connect(connection_name, config) {
-    let cluster = await couchbase.connect(config.nodes, {
+    let connectOptions = {
       username: config.username,
       password: config.password,
-    });
+    };
+    if (config.configProfile) {
+      connectOptions.configProfile = config.configProfile;
+    }
+
+    let cluster = await couchbase.connect(config.nodes, connectOptions);
     let bucket = cluster.bucket(config.bucket);
     let collection;
     let scope_name = this.scope_name || config.scope || "_default";

package/src/index.multi_get.test.js

@@ -0,0 +1,199 @@
+"use strict";
+
+const assert = require("assert");
+const Database = require("./index");
+
+let passed = 0;
+let failed = 0;
+
+function createDb({ lookupIn, get }) {
+  const db = Object.create(Database.prototype);
+  const collection = {
+    lookupIn,
+    get,
+  };
+
+  db.use_bucket_name = false;
+  db.collection = collection;
+  db.connection = collection;
+
+  return db;
+}
+
+async function test(name, fn) {
+  try {
+    await fn();
+    console.log(`✓ ${name}`);
+    passed++;
+  } catch (error) {
+    console.log(`✗ ${name}`);
+    console.log(`  Error: ${error.message}`);
+    failed++;
+  }
+}
+
+async function run() {
+  console.log("\n--- multi_get tests ---");
+
+  await test("lookupIn success with dotted object path does not fallback to get", async () => {
+    let getCalls = 0;
+    const db = createDb({
+      lookupIn: async () => ({
+        content: [{ value: "Alice", error: null }],
+      }),
+      get: async () => {
+        getCalls++;
+        return { content: { profile: { name: "Alice" } } };
+      },
+    });
+
+    const result = await db.multi_get(["doc-1"], {
+      columns: ["profile.name"],
+    });
+
+    assert.deepStrictEqual(result, [
+      {
+        id: "doc-1",
+        "profile.name": "Alice",
+      },
+    ]);
+    assert.strictEqual(getCalls, 0);
+  });
+
+  await test("array-mapped dotted path falls back and returns mapped array values", async () => {
+    const db = createDb({
+      lookupIn: async () => ({
+        content: [{ value: undefined, error: new Error("path mismatch") }],
+      }),
+      get: async () => ({
+        content: {
+          tags: [{ name: "vip" }, { name: "beta" }],
+        },
+      }),
+    });
+
+    const result = await db.multi_get(["doc-1"], {
+      columns: ["tags.name"],
+    });
+
+    assert.deepStrictEqual(result, [
+      {
+        id: "doc-1",
+        "tags.name": ["vip", "beta"],
+      },
+    ]);
+  });
+
+  await test("missing dotted fields return typed empties (object and array)", async () => {
+    const db = createDb({
+      lookupIn: async () => ({
+        content: [{ value: undefined, error: new Error("path mismatch") }],
+      }),
+      get: async () => ({
+        content: {
+          profile: {},
+          tags: [],
+        },
+      }),
+    });
+
+    const result = await db.multi_get(["doc-1"], {
+      columns: ["profile.details", "tags.name"],
+    });
+
+    assert.deepStrictEqual(result, [
+      {
+        id: "doc-1",
+        "profile.details": {},
+        "tags.name": [],
+      },
+    ]);
+  });
+
+  await test("mixed key outcomes keep order and omit missing docs", async () => {
+    const db = createDb({
+      lookupIn: async (key) => {
+        if (key === "a") {
+          return { content: [{ value: "Alice", error: null }] };
+        }
+        if (key === "b") {
+          return {
+            content: [{ value: undefined, error: new Error("path mismatch") }],
+          };
+        }
+        throw new Error("not found");
+      },
+      get: async (key) => {
+        if (key === "b") {
+          return {
+            content: {
+              tags: [{ name: "vip" }, { name: "beta" }],
+            },
+          };
+        }
+        throw new Error("not found");
+      },
+    });
+
+    const result = await db.multi_get(["a", "b", "c"], {
+      columns: ["tags.name"],
+    });
+
+    assert.deepStrictEqual(result, [
+      {
+        id: "a",
+        "tags.name": "Alice",
+      },
+      {
+        id: "b",
+        "tags.name": ["vip", "beta"],
+      },
+    ]);
+  });
+
+  await test("non-column multi_get behavior remains unchanged", async () => {
+    const db = createDb({
+      lookupIn: async () => {
+        throw new Error("should not be called");
+      },
+      get: async (key) => {
+        if (key === "missing") {
+          throw new Error("not found");
+        }
+        return {
+          value: {
+            type: "user",
+            name: key.toUpperCase(),
+          },
+        };
+      },
+    });
+
+    const result = await db.multi_get(["a", "missing", "b"], {
+      keep_type: false,
+    });
+
+    assert.deepStrictEqual(result, [
+      {
+        name: "A",
+        id: "a",
+      },
+      {
+        name: "B",
+        id: "b",
+      },
+    ]);
+  });
+
+  console.log(`\nPassed: ${passed}`);
+  console.log(`Failed: ${failed}`);
+
+  if (failed > 0) {
+    process.exitCode = 1;
+  }
+}
+
+run().catch((error) => {
+  console.error(error);
+  process.exit(1);
+});

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`"));