spice-couchbase 2.0.47 → 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";

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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "spice-couchbase",
-  "version": "2.0.47",
+  "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);
+});