couchbase 4.2.8 → 4.2.10

package/src/instance.cpp

@@ -4,7 +4,7 @@ namespace couchnode
 {
 
 Instance::Instance()
-    : _cluster(couchbase::core::cluster::create(_io))
+    : _cluster(couchbase::core::cluster(_io))
 {
     _ioThread = std::thread([this]() { _io.run(); });
 }
@@ -15,7 +15,7 @@ Instance::~Instance()
 
 void Instance::asyncDestroy()
 {
-    _cluster->close([this]() mutable {
+    _cluster.close([this]() mutable {
         // We have to run this on a separate thread since the callback itself is
         // actually running from within the io context.
         std::thread([this]() {

package/src/instance.hpp

@@ -19,7 +19,7 @@ public:
 
     asio::io_context _io;
     std::thread _ioThread;
-    std::shared_ptr<couchbase::core::cluster> _cluster;
+    couchbase::core::cluster _cluster;
 };
 
 } // namespace couchnode

package/src/jstocbpp_autogen.hpp

@@ -5,6 +5,7 @@
 #include "jstocbpp_cpptypes.hpp"
 
 #include <core/cluster.hxx>
+#include <core/operations.hxx>
 #include <core/operations/management/analytics.hxx>
 #include <core/operations/management/bucket.hxx>
 #include <core/operations/management/bucket_describe.hxx>
@@ -1277,11 +1278,11 @@ struct js_to_cbpp_t<couchbase::core::management::search::index> {
 };
 
 template <>
-struct js_to_cbpp_t<couchbase::management::query::index> {
-    static inline couchbase::management::query::index from_js(Napi::Value jsVal)
+struct js_to_cbpp_t<couchbase::management::query_index> {
+    static inline couchbase::management::query_index from_js(Napi::Value jsVal)
     {
         auto jsObj = jsVal.ToObject();
-        couchbase::management::query::index cppObj;
+        couchbase::management::query_index cppObj;
         js_to_cbpp<bool>(cppObj.is_primary, jsObj.Get("is_primary"));
         js_to_cbpp<std::string>(cppObj.name, jsObj.Get("name"));
         js_to_cbpp<std::string>(cppObj.state, jsObj.Get("state"));
@@ -1300,7 +1301,7 @@ struct js_to_cbpp_t<couchbase::management::query::index> {
         return cppObj;
     }
     static inline Napi::Value
-    to_js(Napi::Env env, const couchbase::management::query::index &cppObj)
+    to_js(Napi::Env env, const couchbase::management::query_index &cppObj)
     {
         auto resObj = Napi::Object::New(env);
         resObj.Set("is_primary", cbpp_to_js<bool>(env, cppObj.is_primary));
@@ -1363,7 +1364,7 @@ struct js_to_cbpp_t<
         couchbase::core::topology::collections_manifest::collection cppObj;
         js_to_cbpp<std::uint64_t>(cppObj.uid, jsObj.Get("uid"));
         js_to_cbpp<std::string>(cppObj.name, jsObj.Get("name"));
-        js_to_cbpp<std::uint32_t>(cppObj.max_expiry, jsObj.Get("max_expiry"));
+        js_to_cbpp<std::int32_t>(cppObj.max_expiry, jsObj.Get("max_expiry"));
         js_to_cbpp<std::optional<bool>>(cppObj.history, jsObj.Get("history"));
         return cppObj;
     }
@@ -1376,7 +1377,7 @@ struct js_to_cbpp_t<
         resObj.Set("uid", cbpp_to_js<std::uint64_t>(env, cppObj.uid));
         resObj.Set("name", cbpp_to_js<std::string>(env, cppObj.name));
         resObj.Set("max_expiry",
-                   cbpp_to_js<std::uint32_t>(env, cppObj.max_expiry));
+                   cbpp_to_js<std::int32_t>(env, cppObj.max_expiry));
         resObj.Set("history",
                    cbpp_to_js<std::optional<bool>>(env, cppObj.history));
         return resObj;
@@ -2545,26 +2546,6 @@ struct js_to_cbpp_t<couchbase::core::operations::query_request> {
     }
 };
 
-template <>
-struct js_to_cbpp_t<couchbase::core::operations::mcbp_noop_response> {
-    static inline couchbase::core::operations::mcbp_noop_response
-    from_js(Napi::Value jsVal)
-    {
-        auto jsObj = jsVal.ToObject();
-        couchbase::core::operations::mcbp_noop_response cppObj;
-        // ctx
-        return cppObj;
-    }
-    static inline Napi::Value
-    to_js(Napi::Env env,
-          const couchbase::core::operations::mcbp_noop_response &cppObj)
-    {
-        auto resObj = Napi::Object::New(env);
-        // ctx
-        return resObj;
-    }
-};
-
 template <>
 struct js_to_cbpp_t<couchbase::core::operations::replace_response> {
     static inline couchbase::core::operations::replace_response
@@ -3893,6 +3874,13 @@ struct js_to_cbpp_t<couchbase::core::operations::search_request> {
         js_to_cbpp<std::string>(cppObj.index_name, jsObj.Get("index_name"));
         js_to_cbpp<couchbase::core::json_string>(cppObj.query,
                                                  jsObj.Get("query"));
+        js_to_cbpp<std::optional<bool>>(cppObj.show_request,
+                                        jsObj.Get("show_request"));
+        js_to_cbpp<std::optional<couchbase::core::json_string>>(
+            cppObj.vector_search, jsObj.Get("vector_search"));
+        js_to_cbpp<std::optional<couchbase::core::vector_query_combination>>(
+            cppObj.vector_query_combination,
+            jsObj.Get("vector_query_combination"));
         js_to_cbpp<std::optional<std::uint32_t>>(cppObj.limit,
                                                  jsObj.Get("limit"));
         js_to_cbpp<std::optional<std::uint32_t>>(cppObj.skip,
@@ -3937,6 +3925,16 @@ struct js_to_cbpp_t<couchbase::core::operations::search_request> {
                    cbpp_to_js<std::string>(env, cppObj.index_name));
         resObj.Set("query",
                    cbpp_to_js<couchbase::core::json_string>(env, cppObj.query));
+        resObj.Set("show_request",
+                   cbpp_to_js<std::optional<bool>>(env, cppObj.show_request));
+        resObj.Set("vector_search",
+                   cbpp_to_js<std::optional<couchbase::core::json_string>>(
+                       env, cppObj.vector_search));
+        resObj.Set(
+            "vector_query_combination",
+            cbpp_to_js<
+                std::optional<couchbase::core::vector_query_combination>>(
+                env, cppObj.vector_query_combination));
         resObj.Set("limit",
                    cbpp_to_js<std::optional<std::uint32_t>>(env, cppObj.limit));
         resObj.Set("skip",
@@ -5170,7 +5168,7 @@ struct js_to_cbpp_t<
             cppObj;
         // ctx
         js_to_cbpp<std::string>(cppObj.status, jsObj.Get("status"));
-        js_to_cbpp<std::vector<couchbase::management::query::index>>(
+        js_to_cbpp<std::vector<couchbase::management::query_index>>(
             cppObj.indexes, jsObj.Get("indexes"));
         return cppObj;
     }
@@ -5182,7 +5180,7 @@ struct js_to_cbpp_t<
         // ctx
         resObj.Set("status", cbpp_to_js<std::string>(env, cppObj.status));
         resObj.Set("indexes",
-                   cbpp_to_js<std::vector<couchbase::management::query::index>>(
+                   cbpp_to_js<std::vector<couchbase::management::query_index>>(
                        env, cppObj.indexes));
         return resObj;
     }
@@ -5271,7 +5269,7 @@ struct js_to_cbpp_t<
         js_to_cbpp<std::string>(cppObj.scope_name, jsObj.Get("scope_name"));
         js_to_cbpp<std::string>(cppObj.collection_name,
                                 jsObj.Get("collection_name"));
-        js_to_cbpp<std::uint32_t>(cppObj.max_expiry, jsObj.Get("max_expiry"));
+        js_to_cbpp<std::int32_t>(cppObj.max_expiry, jsObj.Get("max_expiry"));
         js_to_cbpp<std::optional<bool>>(cppObj.history, jsObj.Get("history"));
         js_to_cbpp<std::optional<std::string>>(cppObj.client_context_id,
                                                jsObj.Get("client_context_id"));
@@ -5292,7 +5290,7 @@ struct js_to_cbpp_t<
         resObj.Set("collection_name",
                    cbpp_to_js<std::string>(env, cppObj.collection_name));
         resObj.Set("max_expiry",
-                   cbpp_to_js<std::uint32_t>(env, cppObj.max_expiry));
+                   cbpp_to_js<std::int32_t>(env, cppObj.max_expiry));
         resObj.Set("history",
                    cbpp_to_js<std::optional<bool>>(env, cppObj.history));
         resObj.Set("client_context_id", cbpp_to_js<std::optional<std::string>>(
@@ -7121,8 +7119,8 @@ struct js_to_cbpp_t<
         js_to_cbpp<std::string>(cppObj.scope_name, jsObj.Get("scope_name"));
         js_to_cbpp<std::string>(cppObj.collection_name,
                                 jsObj.Get("collection_name"));
-        js_to_cbpp<std::optional<std::uint32_t>>(cppObj.max_expiry,
-                                                 jsObj.Get("max_expiry"));
+        js_to_cbpp<std::optional<std::int32_t>>(cppObj.max_expiry,
+                                                jsObj.Get("max_expiry"));
         js_to_cbpp<std::optional<bool>>(cppObj.history, jsObj.Get("history"));
         js_to_cbpp<std::optional<std::string>>(cppObj.client_context_id,
                                                jsObj.Get("client_context_id"));
@@ -7142,7 +7140,7 @@ struct js_to_cbpp_t<
                    cbpp_to_js<std::string>(env, cppObj.scope_name));
         resObj.Set("collection_name",
                    cbpp_to_js<std::string>(env, cppObj.collection_name));
-        resObj.Set("max_expiry", cbpp_to_js<std::optional<std::uint32_t>>(
+        resObj.Set("max_expiry", cbpp_to_js<std::optional<std::int32_t>>(
                                      env, cppObj.max_expiry));
         resObj.Set("history",
                    cbpp_to_js<std::optional<bool>>(env, cppObj.history));
@@ -8707,21 +8705,22 @@ struct js_to_cbpp_t<couchbase::core::operations::management::
 
 template <>
 struct js_to_cbpp_t<
-    couchbase::core::operations::management::search_index_stats_response> {
+    couchbase::core::operations::management::search_get_stats_response> {
     static inline couchbase::core::operations::management::
-        search_index_stats_response
+        search_get_stats_response
         from_js(Napi::Value jsVal)
     {
         auto jsObj = jsVal.ToObject();
-        couchbase::core::operations::management::search_index_stats_response
+        couchbase::core::operations::management::search_get_stats_response
             cppObj;
         // ctx
         js_to_cbpp<std::string>(cppObj.stats, jsObj.Get("stats"));
         return cppObj;
     }
-    static inline Napi::Value
-    to_js(Napi::Env env, const couchbase::core::operations::management::
-                             search_index_stats_response &cppObj)
+    static inline Napi::Value to_js(
+        Napi::Env env,
+        const couchbase::core::operations::management::search_get_stats_response
+            &cppObj)
     {
         auto resObj = Napi::Object::New(env);
         // ctx
@@ -8732,13 +8731,13 @@ struct js_to_cbpp_t<
 
 template <>
 struct js_to_cbpp_t<
-    couchbase::core::operations::management::search_index_stats_request> {
+    couchbase::core::operations::management::search_get_stats_request> {
     static inline couchbase::core::operations::management::
-        search_index_stats_request
+        search_get_stats_request
         from_js(Napi::Value jsVal)
     {
         auto jsObj = jsVal.ToObject();
-        couchbase::core::operations::management::search_index_stats_request
+        couchbase::core::operations::management::search_get_stats_request
             cppObj;
         js_to_cbpp<std::optional<std::string>>(cppObj.client_context_id,
                                                jsObj.Get("client_context_id"));
@@ -8746,9 +8745,10 @@ struct js_to_cbpp_t<
             cppObj.timeout, jsObj.Get("timeout"));
         return cppObj;
     }
-    static inline Napi::Value
-    to_js(Napi::Env env, const couchbase::core::operations::management::
-                             search_index_stats_request &cppObj)
+    static inline Napi::Value to_js(
+        Napi::Env env,
+        const couchbase::core::operations::management::search_get_stats_request
+            &cppObj)
     {
         auto resObj = Napi::Object::New(env);
         resObj.Set("client_context_id", cbpp_to_js<std::optional<std::string>>(

package/src/jstocbpp_basic.hpp

@@ -6,6 +6,8 @@
 #include "mutationtoken.hpp"
 
 #include <core/cluster.hxx>
+#include <core/document_id.hxx>
+#include <core/json_string.hxx>
 #include <core/query_context.hxx>
 
 namespace couchnode

package/src/jstocbpp_errors.hpp

@@ -6,6 +6,7 @@
 
 #include <core/cluster.hxx>
 #include <core/operations/management/error_utils.hxx>
+#include <couchbase/query_error_context.hxx>
 
 namespace couchnode
 {

package/src/jstocbpp_transactions.hpp

@@ -47,17 +47,9 @@ struct js_to_cbpp_t<cbtxns::transactions_config> {
             cppObj.durability_level(durability_level.value());
         }
 
-        auto kv_timeout = js_to_cbpp<std::optional<std::chrono::milliseconds>>(
-            jsObj.Get("kv_timeout"));
-        if (kv_timeout.has_value()) {
-            cppObj.kv_timeout(kv_timeout.value());
-        }
-
-        auto expiration_time =
-            js_to_cbpp<std::optional<std::chrono::milliseconds>>(
-                jsObj.Get("expiration_time"));
-        if (expiration_time.has_value()) {
-            cppObj.expiration_time(expiration_time.value());
+        auto timeout = js_to_cbpp<std::optional<std::chrono::milliseconds>>(jsObj.Get("timeout"));
+        if (timeout.has_value()) {
+            cppObj.timeout(timeout.value());
         }
 
         auto query_scan_consistency =
@@ -107,17 +99,9 @@ struct js_to_cbpp_t<cbtxns::transaction_options> {
             cppObj.durability_level(durability_level.value());
         }
 
-        auto kv_timeout = js_to_cbpp<std::optional<std::chrono::milliseconds>>(
-            jsObj.Get("kv_timeout"));
-        if (kv_timeout.has_value()) {
-            cppObj.kv_timeout(kv_timeout.value());
-        }
-
-        auto expiration_time =
-            js_to_cbpp<std::optional<std::chrono::milliseconds>>(
-                jsObj.Get("expiration_time"));
-        if (expiration_time.has_value()) {
-            cppObj.expiration_time(expiration_time.value());
+        auto timeout = js_to_cbpp<std::optional<std::chrono::milliseconds>>(jsObj.Get("timeout"));
+        if (timeout.has_value()) {
+            cppObj.timeout(timeout.value());
         }
 
         auto query_scan_consistency =

package/src/mutationtoken.hpp

@@ -2,6 +2,7 @@
 #include "addondata.hpp"
 #include "napi.h"
 #include <core/cluster.hxx>
+#include <couchbase/mutation_token.hxx>
 
 namespace couchnode
 {

package/tools/gen-bindings-json.py

@@ -3,6 +3,8 @@ import json
 import re
 import clang.cindex
 
+from functools import reduce
+
 # configurable part
 
 CLANG_VERSION='13.0.1'
@@ -11,7 +13,16 @@ CLANG_VERSION='13.0.1'
 #       arm64: /opt/homebrew/opt/llvm/lib
 llvmLibPath = "/usr/local/Cellar/llvm/13.0.1_1/lib/"
 
-cxxClientRoot = "../deps/couchbase-cxx-client"
+cxx_client_root = "../deps/couchbase-cxx-client"
+cxx_client_cache = "../deps/couchbase-cxx-cache"
+cxx_deps_include_paths = {
+    'asio': ['-I{0}/asio/{1}/asio/asio/include'],
+    'fmt': ['-I{0}/fmt/{1}/fmt/include'],
+    'gsl': ['-I{0}/gsl/{1}/gsl/include'],
+    'json': ['-I{0}/json/{1}/json/include',
+             '-I{0}/json/{1}/json/external/PEGTL/include'
+             ],
+}
 
 fileList = [
     "core/management/analytics_dataset.hxx",
@@ -61,6 +72,7 @@ fileList = [
     "core/scan_options.hxx",
     "core/range_scan_orchestrator_options.hxx",
     "core/query_context.hxx",
+    "core/vector_query_combination.hxx",
 ]
 
 typeList = [
@@ -89,7 +101,7 @@ typeList = [
     "couchbase::core::management::rbac::user_and_metadata",
     "couchbase::core::management::rbac::group",
     "couchbase::core::management::search::index",
-    "couchbase::management::query::index",
+    "couchbase::management::query_index",
     "couchbase::retry_reason",
     "couchbase::core::topology::collections_manifest",
     "couchbase::core::protocol::status",
@@ -154,12 +166,22 @@ typeList = [
     "couchbase::core::range_scan_continue_result",
     "couchbase::core::range_scan_cancel_result",
     "couchbase::core::query_context",
+    "couchbase::core::vector_query_combination",
 ]
 
 # end of configurable part
 
 clang.cindex.Config.set_library_path(llvmLibPath)
 
+def set_cxx_deps_include_paths(dep, includes):
+    cpm_path = os.path.join(cxx_client_cache, dep)
+    dir_pattern = r'[0-9a-z]{40}'
+    cpm_hash_dir = next((d for d in os.listdir(cpm_path)
+                         if os.path.isdir(os.path.join(cpm_path, d)) and re.match(dir_pattern, d)),
+                         None)
+    if not cpm_hash_dir:
+        raise Exception(f'Unable to find CPM hash directory for path: {cpm_path}.')
+    return list(map(lambda p: p.format(cxx_client_cache, cpm_hash_dir), includes))
 
 def list_headers_in_dir(path):
     # enumerates a folder but keeps the full pathing for the files returned
@@ -184,11 +206,11 @@ for filePath in fileList:
             # if there is still a wildcard, we have an issue...
             raise NotImplementedError(
                 "wildcard only supported at end of file path")
-        files = list_headers_in_dir(os.path.join(cxxClientRoot, basePath))
+        files = list_headers_in_dir(os.path.join(cxx_client_root, basePath))
         fullFileList = fullFileList + files
     else:
         # normal path
-        fullFileList.append(os.path.join(cxxClientRoot, filePath))
+        fullFileList.append(os.path.join(cxx_client_root, filePath))
 
 # exclude _json.hxx files
 fullFileList = list(
@@ -228,7 +250,11 @@ def parse_type(type):
     typeStr = type.get_canonical().spelling
     return parse_type_str(typeStr)
 
-std_comparators = ["std::less<>", "std::greater<>", "std::less_equal<>", "std::greater_equal<>"]
+std_comparator_templates = ["std::less<{0}>", "std::greater<{0}>", "std::less_equal<{0}>", "std::greater_equal<{0}>"]
+# flatten the list of lists
+std_comparators = list(reduce(lambda a, b: a + b,
+                              list(map(lambda c: [c.format(s) for s in ['', 'void']], std_comparator_templates)),
+                              []))
 
 def parse_type_str(typeStr):
     if typeStr == "std::mutex":
@@ -276,6 +302,8 @@ def parse_type_str(typeStr):
     if typeStr == "std::nullptr_t":
         return {"name": "std::nullptr_t"}
     if typeStr in std_comparators:
+        if 'void' in typeStr:
+            return {"name": typeStr.replace("void", "")}
         return {"name": typeStr}
 
     tplParts = typeStr.split("<", 1)
@@ -440,20 +468,17 @@ def traverse(node, namespace, main_file):
     for child in node.get_children():
         traverse(child, namespace, main_file)
 
+include_paths = [
+    f'-I{cxx_client_root}/',
+    f'-I/Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/clang/{CLANG_VERSION}/include',
+]
+for dep, inc in cxx_deps_include_paths.items():
+    include_paths.extend(set_cxx_deps_include_paths(dep, inc))
+
 for headerPath in fullFileList:
     print("processing " + headerPath)
     index = clang.cindex.Index.create()
-    args = [
-        '-std=c++17',
-        "-I" + cxxClientRoot + "/",
-        "-I" + cxxClientRoot + "/third_party/fmt/include",
-        "-I" + cxxClientRoot + "/third_party/gsl/include",
-        "-I" + cxxClientRoot + "/third_party/json/include",
-        "-I" + cxxClientRoot + "/third_party/json/external/PEGTL/include",
-        "-I" + cxxClientRoot + "/third_party/asio/asio/include",
-        "-I" + f"/Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/clang/{CLANG_VERSION}/include",
-        # "-I" + f'/opt/homebrew/Cellar/llvm/{CLANG_VERSION}/lib/clang/{CLANG_VERSION[:2]}/include',
-    ]
+    args = ['-std=c++17'] + include_paths
     translation_unit = index.parse(headerPath, args=args)
 
     # output clang compiler diagnostics information (for debugging)

package/deps/couchbase-cxx-client/core/impl/append.cxx

@@ -1,87 +0,0 @@
-/* -*- Mode: C++; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */
-/*
- *   Copyright 2020-Present Couchbase, Inc.
- *
- *   Licensed under the Apache License, Version 2.0 (the "License");
- *   you may not use this file except in compliance with the License.
- *   You may obtain a copy of the License at
- *
- *       http://www.apache.org/licenses/LICENSE-2.0
- *
- *   Unless required by applicable law or agreed to in writing, software
- *   distributed under the License is distributed on an "AS IS" BASIS,
- *   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- *   See the License for the specific language governing permissions and
- *   limitations under the License.
- */
-
-#include "core/cluster.hxx"
-#include "core/error_context/key_value.hxx"
-#include "core/impl/observe_poll.hxx"
-#include "core/impl/observe_seqno.hxx"
-#include "core/operations/document_append.hxx"
-
-#include <couchbase/append_options.hxx>
-
-namespace couchbase::core::impl
-{
-void
-initiate_append_operation(std::shared_ptr<couchbase::core::cluster> core,
-                          std::string bucket_name,
-                          std::string scope_name,
-                          std::string collection_name,
-                          std::string document_key,
-                          std::vector<std::byte> data,
-                          append_options::built options,
-                          append_handler&& handler)
-{
-    auto id = document_id{
-        std::move(bucket_name),
-        std::move(scope_name),
-        std::move(collection_name),
-        std::move(document_key),
-    };
-    if (options.persist_to == persist_to::none && options.replicate_to == replicate_to::none) {
-        return core->execute(
-          operations::append_request{
-            std::move(id),
-            std::move(data),
-            {},
-            {},
-            options.durability_level,
-            options.timeout,
-            { options.retry_strategy },
-          },
-          [handler = std::move(handler)](operations::append_response&& resp) mutable {
-              if (resp.ctx.ec()) {
-                  return handler(std::move(resp.ctx), mutation_result{});
-              }
-              return handler(std::move(resp.ctx), mutation_result{ resp.cas, std::move(resp.token) });
-          });
-    }
-
-    operations::append_request request{
-        id, std::move(data), {}, {}, durability_level::none, options.timeout, { options.retry_strategy },
-    };
-    return core->execute(
-      std::move(request), [core, id = std::move(id), options, handler = std::move(handler)](operations::append_response&& resp) mutable {
-          if (resp.ctx.ec()) {
-              return handler(std::move(resp.ctx), mutation_result{ resp.cas, std::move(resp.token) });
-          }
-
-          initiate_observe_poll(core,
-                                std::move(id),
-                                resp.token,
-                                options.timeout,
-                                options.persist_to,
-                                options.replicate_to,
-                                [resp = std::move(resp), handler = std::move(handler)](std::error_code ec) mutable {
-                                    if (ec) {
-                                        resp.ctx.override_ec(ec);
-                                        return handler(std::move(resp.ctx), mutation_result{});
-                                    }
-                                    return handler(std::move(resp.ctx), mutation_result{ resp.cas, std::move(resp.token) });
-                                });
-      });
-}
-} // namespace couchbase::core::impl