spice-couchbase 2.0.46 → 2.0.48

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";
@@ -824,9 +830,7 @@ module.exports = class Database {
         }); // 4. Execute the index creation if we got a valid statement
 
         if (indexStatement) {
-          console.log("Executing index creation:", indexStatement);
           var response = yield exec_scope.query(indexStatement);
-          console.log("Index creation response:", response);
         }
       } catch (e) {// Silently handle errors (index may already exist, etc.)
       }
@@ -859,10 +863,10 @@ module.exports = class Database {
       var endTime = process.hrtime.bigint(); // Calculate duration in microseconds
 
       var durationInMilliseconds = (endTime - startTime) / BigInt(1000000); // optimize if response time is greater than 1 second
-      //if (durationInMilliseconds > 2000) {
-
-      _this19.optimize(query, exec_scope); //}
 
+      if (durationInMilliseconds > 2000) {
+        _this19.optimize(query, exec_scope);
+      }
 
       return response;
     })();

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

@@ -323,22 +323,17 @@ function buildCoveringIndex(query, options) {
   if (allFields.length === 0) {
     // No fields to index besides deleted
     return null;
-  } // Generate unique index name based on query hash
+  } // Build the field list with deleted INCLUDE MISSING first
 
 
-  var hash = generateHash(query);
-  var indexName = "adv_covered_".concat(hash); // 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
+  // This ensures multiple queries covered by the same index get the same hash
 
-  var fieldList = ["`deleted` INCLUDE MISSING", ...allFields.map(f => "`".concat(f, "`"))].join(", "); // Build the CREATE INDEX statement
+  var indexKey = "".concat(bucket, "|").concat(scope, "|").concat(collection, "|").concat(allFields.sort().join(","));
+  var hash = generateHash(indexKey);
+  var indexName = "adv_covered_".concat(hash); // Build the CREATE INDEX statement
 
-  var indexStatement = "CREATE INDEX `".concat(indexName, "` ON `default`:`").concat(bucket, "`.`").concat(scope, "`.`").concat(collection, "`(").concat(fieldList, ")"); // Debug logs
-
-  console.log("[DEBUG buildCoveringIndex] Original query:", query);
-  console.log("[DEBUG buildCoveringIndex] WHERE fields:", filteredWhereFields);
-  console.log("[DEBUG buildCoveringIndex] GROUP BY fields:", filteredGroupByFields);
-  console.log("[DEBUG buildCoveringIndex] ORDER BY fields:", filteredOrderByFields);
-  console.log("[DEBUG buildCoveringIndex] SELECT fields:", selectFieldsFiltered);
-  console.log("[DEBUG buildCoveringIndex] Index statement:", indexStatement);
+  var indexStatement = "CREATE INDEX `".concat(indexName, "` ON `default`:`").concat(bucket, "`.`").concat(scope, "`.`").concat(collection, "`(").concat(fieldList, ")");
   return indexStatement;
 }
 

package/build/utility.test.js

@@ -586,6 +586,29 @@ test("consistent index name for same query", () => {
   var result2 = buildCoveringIndex(query, defaultOptions);
   assert.strictEqual(result1, result2);
 });
+test("same index name for different queries with same fields", () => {
+  // Two different queries that would be covered by the same index
+  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 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
+
+  assert.strictEqual(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'";
+  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]; // 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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "spice-couchbase",
-  "version": "2.0.46",
+  "version": "2.0.48",
   "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

@@ -342,16 +342,18 @@ function buildCoveringIndex(query, options) {
     return null;
   }
 
-  // Generate unique index name based on query hash
-  const hash = generateHash(query);
-  const indexName = `adv_covered_${hash}`;
-
   // Build the field list with deleted INCLUDE MISSING first
   const fieldList = [
     "`deleted` INCLUDE MISSING",
     ...allFields.map((f) => `\`${f}\``),
   ].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 hash = generateHash(indexKey);
+  const indexName = `adv_covered_${hash}`;
+
   // Build the CREATE INDEX statement
   const indexStatement = `CREATE INDEX \`${indexName}\` ON \`default\`:\`${bucket}\`.\`${scope}\`.\`${collection}\`(${fieldList})`;
 

package/src/utility.test.js

@@ -706,6 +706,37 @@ test("consistent index name for same query", () => {
   assert.strictEqual(result1, result2);
 });
 
+test("same index name for different queries with same fields", () => {
+  // Two different queries that would be covered by the same index
+  const query1 = "SELECT name, email FROM users WHERE status = 'active'";
+  const query2 = "SELECT email, name FROM users WHERE status = 'pending'";
+  
+  const result1 = buildCoveringIndex(query1, defaultOptions);
+  const result2 = buildCoveringIndex(query2, defaultOptions);
+  
+  // Extract index names
+  const name1 = result1.match(/CREATE INDEX `(adv_covered_\w+)`/)[1];
+  const 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 queries with different fields", () => {
+  const query1 = "SELECT name FROM users WHERE status = 'active'";
+  const query2 = "SELECT email FROM users WHERE type = 'admin'";
+  
+  const result1 = buildCoveringIndex(query1, defaultOptions);
+  const result2 = buildCoveringIndex(query2, defaultOptions);
+  
+  // Extract index names
+  const name1 = result1.match(/CREATE INDEX `(adv_covered_\w+)`/)[1];
+  const 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", () => {
   const query = `SELECT 
     first_name,