couchbase 4.3.1 → 4.4.0

package/src/jstocbpp_errors.hpp

@@ -6,7 +6,7 @@
 
 #include <core/cluster.hxx>
 #include <core/operations/management/error_utils.hxx>
-#include <couchbase/query_error_context.hxx>
+#include <core/error_context/query_error_context.hxx>
 
 namespace couchnode
 {
@@ -41,9 +41,9 @@ struct js_to_cbpp_t<std::error_code> {
 };
 
 template <>
-struct js_to_cbpp_t<couchbase::key_value_extended_error_info> {
+struct js_to_cbpp_t<couchbase::core::key_value_extended_error_info> {
     static inline Napi::Value
-    to_js(Napi::Env env, const couchbase::key_value_extended_error_info &cppObj)
+    to_js(Napi::Env env, const couchbase::core::key_value_extended_error_info &cppObj)
     {
         auto resObj = Napi::Object::New(env);
         resObj.Set("reference", cbpp_to_js(env, cppObj.reference()));
@@ -53,9 +53,9 @@ struct js_to_cbpp_t<couchbase::key_value_extended_error_info> {
 };
 
 template <>
-struct js_to_cbpp_t<couchbase::key_value_error_context> {
+struct js_to_cbpp_t<couchbase::core::key_value_error_context> {
     static inline Napi::Value
-    to_js(Napi::Env env, const couchbase::key_value_error_context &ctx)
+    to_js(Napi::Env env, const couchbase::core::key_value_error_context &ctx)
     {
         if (!ctx.ec()) {
             return env.Null();
@@ -81,9 +81,9 @@ struct js_to_cbpp_t<couchbase::key_value_error_context> {
 };
 
 template <>
-struct js_to_cbpp_t<couchbase::subdocument_error_context> {
+struct js_to_cbpp_t<couchbase::core::subdocument_error_context> {
     static inline Napi::Value
-    to_js(Napi::Env env, const couchbase::subdocument_error_context &ctx)
+    to_js(Napi::Env env, const couchbase::core::subdocument_error_context &ctx)
     {
         if (!ctx.ec()) {
             return env.Null();
@@ -189,9 +189,9 @@ struct js_to_cbpp_t<couchbase::core::error_context::query> {
 };
 
 template <>
-struct js_to_cbpp_t<couchbase::query_error_context> {
+struct js_to_cbpp_t<couchbase::core::query_error_context> {
     static inline Napi::Value to_js(Napi::Env env,
-                                    const couchbase::query_error_context &ctx)
+                                    const couchbase::core::query_error_context &ctx)
     {
         if (!ctx.ec()) {
             return env.Null();

package/src/jstocbpp_transactions.hpp

@@ -5,6 +5,7 @@
 #include "jstocbpp_cpptypes.hpp"
 
 #include <core/cluster.hxx>
+#include <core/error_context/transaction_error_context.hxx>
 #include <core/transactions.hxx>
 #include <core/transactions/internal/exceptions_internal.hxx>
 #include <core/utils/json.hxx>
@@ -141,8 +142,9 @@ struct js_to_cbpp_t<cbcoretxns::transaction_links> {
                 jsObj.Get("staged_attempt_id")),
             js_to_cbpp<std::optional<std::string>>(
                 jsObj.Get("staged_operation_id")),
-            js_to_cbpp<std::optional<std::vector<std::byte>>>(
+            js_to_cbpp<std::optional<couchbase::codec::encoded_value>>(
                 jsObj.Get("staged_content")),
+            {},
             js_to_cbpp<std::optional<std::string>>(jsObj.Get("cas_pre_txn")),
             js_to_cbpp<std::optional<std::string>>(jsObj.Get("revid_pre_txn")),
             js_to_cbpp<std::optional<uint32_t>>(jsObj.Get("exptime_pre_txn")),
@@ -169,7 +171,8 @@ struct js_to_cbpp_t<cbcoretxns::transaction_links> {
                    cbpp_to_js(env, res.staged_attempt_id()));
         resObj.Set("staged_operation_id",
                    cbpp_to_js(env, res.staged_operation_id()));
-        resObj.Set("staged_content", cbpp_to_js(env, res.staged_content()));
+        resObj.Set("staged_content",
+                   cbpp_to_js(env, res.staged_content_json()));
         resObj.Set("cas_pre_txn", cbpp_to_js(env, res.cas_pre_txn()));
         resObj.Set("revid_pre_txn", cbpp_to_js(env, res.revid_pre_txn()));
         resObj.Set("exptime_pre_txn", cbpp_to_js(env, res.exptime_pre_txn()));
@@ -240,7 +243,7 @@ struct js_to_cbpp_t<cbcoretxns::transaction_get_result> {
         auto jsObj = jsVal.ToObject();
         return cbcoretxns::transaction_get_result(
             js_to_cbpp<couchbase::core::document_id>(jsObj.Get("id")),
-            js_to_cbpp<std::vector<std::byte>>(jsObj.Get("content")),
+            js_to_cbpp<couchbase::codec::encoded_value>(jsObj.Get("content")),
             js_to_cbpp<couchbase::cas>(jsObj.Get("cas")).value(),
             js_to_cbpp<cbcoretxns::transaction_links>(jsObj.Get("links")),
             js_to_cbpp<std::optional<cbcoretxns::document_metadata>>(
@@ -253,7 +256,7 @@ struct js_to_cbpp_t<cbcoretxns::transaction_get_result> {
         auto resObj = Napi::Object::New(env);
         resObj.Set("id", cbpp_to_js(env, res.id()));
         resObj.Set("content",
-                   cbpp_to_js<std::vector<std::byte>>(env, res.content()));
+                   cbpp_to_js<std::vector<std::byte>>(env, res.content().data));
         resObj.Set("cas", cbpp_to_js(env, couchbase::cas{res.cas()}));
         resObj.Set("links", cbpp_to_js(env, res.links()));
         resObj.Set("metadata", cbpp_to_js(env, res.metadata()));
@@ -406,9 +409,9 @@ struct js_to_cbpp_t<cbtxns::transaction_result> {
 };
 
 template <>
-struct js_to_cbpp_t<couchbase::transaction_error_context> {
+struct js_to_cbpp_t<couchbase::core::transaction_error_context> {
     static inline Napi::Value
-    to_js(Napi::Env env, const couchbase::transaction_error_context &res)
+    to_js(Napi::Env env, const couchbase::core::transaction_error_context &res)
     {
         auto resObj = Napi::Object::New(env);
         resObj.Set("code", cbpp_to_js(env, res.ec()));
@@ -432,16 +435,18 @@ struct js_to_cbpp_t<cbcoretxns::op_exception> {
 };
 
 template <>
-struct js_to_cbpp_t<couchbase::transaction_op_error_context> {
+struct js_to_cbpp_t<couchbase::core::transaction_op_error_context> {
     static inline Napi::Value
-    to_js(Napi::Env env, const couchbase::transaction_op_error_context &res)
+    to_js(Napi::Env env, const couchbase::core::transaction_op_error_context &res)
     {
         auto resObj = Napi::Object::New(env);
         resObj.Set("code", cbpp_to_js(env, res.ec()));
-        resObj.Set("cause",
-                   cbpp_to_js<std::variant<couchbase::key_value_error_context,
-                                           couchbase::query_error_context>>(
-                       env, res.cause()));
+        resObj.Set(
+            "cause",
+            cbpp_to_js<
+                std::variant<std::monostate, couchbase::core::key_value_error_context,
+                             couchbase::core::query_error_context>>(env,
+                                                              res.cause()));
         return resObj;
     }
 };

package/src/transaction.cpp

@@ -64,7 +64,8 @@ Transaction::Transaction(const Napi::CallbackInfo &info)
     auto &transactions = Transactions::Unwrap(txnsJsObj)->transactions();
 
     auto txnConfig = jsToCbpp<cbtxns::transaction_options>(configJsObj);
-    _impl.reset(new cbcoretxns::transaction_context(transactions, txnConfig));
+    _impl.reset();
+    _impl = cbcoretxns::transaction_context::create(transactions, txnConfig);
 }
 
 Transaction::~Transaction()
@@ -74,7 +75,8 @@ Transaction::~Transaction()
 Napi::Value Transaction::jsNewAttempt(const Napi::CallbackInfo &info)
 {
     auto callbackJsFn = info[0].As<Napi::Function>();
-    auto cookie = RefCallCookie(info.Env(), callbackJsFn, "txnNewAttemptCallback");
+    auto cookie =
+        RefCallCookie(info.Env(), callbackJsFn, "txnNewAttemptCallback");
 
     _impl->new_attempt_context(
         [this, cookie = std::move(cookie)](std::exception_ptr err) mutable {
@@ -126,7 +128,8 @@ Napi::Value Transaction::jsInsert(const Napi::CallbackInfo &info)
     auto cookie = RefCallCookie(info.Env(), callbackJsFn, "txnInsertCallback");
 
     auto docId = jsToCbpp<couchbase::core::document_id>(optsJsObj.Get("id"));
-    auto content = jsToCbpp<std::vector<std::byte>>(optsJsObj.Get("content"));
+    auto content =
+        jsToCbpp<couchbase::codec::encoded_value>(optsJsObj.Get("content"));
 
     _impl->insert(
         docId, content,
@@ -150,7 +153,8 @@ Napi::Value Transaction::jsReplace(const Napi::CallbackInfo &info)
 
     auto doc =
         jsToCbpp<cbcoretxns::transaction_get_result>(optsJsObj.Get("doc"));
-    auto content = jsToCbpp<std::vector<std::byte>>(optsJsObj.Get("content"));
+    auto content =
+        jsToCbpp<couchbase::codec::encoded_value>(optsJsObj.Get("content"));
 
     _impl->replace(
         doc, content,
@@ -240,7 +244,8 @@ Napi::Value Transaction::jsCommit(const Napi::CallbackInfo &info)
 Napi::Value Transaction::jsRollback(const Napi::CallbackInfo &info)
 {
     auto callbackJsFn = info[0].As<Napi::Function>();
-    auto cookie = RefCallCookie(info.Env(), callbackJsFn, "txnRollbackCallback");
+    auto cookie =
+        RefCallCookie(info.Env(), callbackJsFn, "txnRollbackCallback");
 
     _impl->rollback(
         [this, cookie = std::move(cookie)](std::exception_ptr err) mutable {

package/tools/gen-bindings-js.js

@@ -231,6 +231,7 @@ function isIgnoredField(st, fieldName) {
     fieldName === 'parent_span' ||
     fieldName === 'retry_strategy' ||
     fieldName === 'internal' ||
+    fieldName === 'read_preference' ||
     (fieldName.endsWith('_') &&
       !StructsWithAllowedPrivateField.includes(st.name))
   ) {

package/tools/gen-bindings-json.py

@@ -22,6 +22,7 @@ cxx_deps_include_paths = {
     'json': ['-I{0}/json/{1}/json/include',
              '-I{0}/json/{1}/json/external/PEGTL/include'
              ],
+    'spdlog': ['-I{0}/spdlog/{1}/spdlog/include'],
 }
 
 fileList = [
@@ -62,12 +63,13 @@ fileList = [
     "couchbase/cas.hxx",
     "couchbase/error_codes.hxx",
     "couchbase/mutation_token.hxx",
-    "couchbase/key_value_status_code.hxx",
+    "core/error_context/key_value_status_code.hxx",
     "core/impl/subdoc/opcode.hxx",
     "core/impl/subdoc/command.hxx",
     "couchbase/store_semantics.hxx",
     "couchbase/persist_to.hxx",
     "couchbase/replicate_to.hxx",
+    "couchbase/read_preference.hxx",
     "core/range_scan_options.hxx",
     "core/range_scan_orchestrator_options.hxx",
     "core/query_context.hxx",
@@ -142,7 +144,7 @@ typeList = [
     "couchbase::core::operations::*",
     "couchbase::core::operations::management::*",
     "couchbase::core::tracing::request_span",
-    "couchbase::key_value_status_code",
+    "couchbase::core::key_value_status_code",
     "couchbase::core::impl::subdoc::command",
     "couchbase::core::impl::subdoc::opcode",
     "couchbase::store_semantics",
@@ -166,6 +168,7 @@ typeList = [
     "couchbase::core::range_scan_cancel_result",
     "couchbase::core::query_context",
     "couchbase::core::vector_query_combination",
+    "couchbase::read_preference"
 ]
 
 # end of configurable part

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

@@ -1,113 +0,0 @@
-/* -*- Mode: C++; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */
-/*
- *   Copyright 2023-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 "internal_manager_error_context.hxx"
-#include <couchbase/error_context.hxx>
-
-#include <optional>
-
-namespace couchbase
-{
-internal_manager_error_context::internal_manager_error_context(internal_manager_error_context&& other) noexcept = default;
-
-internal_manager_error_context&
-internal_manager_error_context::operator=(internal_manager_error_context&& other) noexcept = default;
-
-internal_manager_error_context::internal_manager_error_context(std::error_code ec,
-                                                               std::optional<std::string> last_dispatched_to,
-                                                               std::optional<std::string> last_dispatched_from,
-                                                               std::size_t retry_attempts,
-                                                               std::set<retry_reason> retry_reasons,
-                                                               std::string client_context_id,
-                                                               std::uint32_t http_status,
-                                                               std::string content,
-                                                               std::string path)
-  : ctx_{ ec,
-          std::move(client_context_id),
-          {},
-          std::move(path),
-          http_status,
-          { std::move(content) },
-          {},
-          {},
-          std::move(last_dispatched_to),
-          std::move(last_dispatched_from),
-          retry_attempts,
-          std::move(retry_reasons) }
-{
-}
-
-auto
-internal_manager_error_context::path() const -> const std::string&
-{
-    return ctx_.path;
-}
-
-auto
-internal_manager_error_context::content() const -> const std::string&
-{
-    return ctx_.http_body;
-}
-
-auto
-internal_manager_error_context::client_context_id() const -> const std::string&
-{
-    return ctx_.client_context_id;
-}
-
-auto
-internal_manager_error_context::http_status() const -> std::uint32_t
-{
-    return ctx_.http_status;
-}
-
-auto
-internal_manager_error_context::ec() const -> std::error_code
-{
-    return ctx_.ec;
-}
-
-auto
-internal_manager_error_context::last_dispatched_to() const -> const std::optional<std::string>&
-{
-    return ctx_.last_dispatched_to;
-}
-
-auto
-internal_manager_error_context::last_dispatched_from() const -> const std::optional<std::string>&
-{
-    return ctx_.last_dispatched_from;
-}
-
-auto
-internal_manager_error_context::retry_attempts() const -> std::size_t
-{
-    return ctx_.retry_attempts;
-}
-
-auto
-internal_manager_error_context::retry_reasons() const -> const std::set<retry_reason>&
-{
-    return ctx_.retry_reasons;
-}
-
-auto
-internal_manager_error_context::retried_because_of(retry_reason reason) const -> bool
-{
-    return ctx_.retry_reasons.count(reason) > 0;
-}
-} // namespace couchbase

package/deps/couchbase-cxx-client/core/impl/internal_manager_error_context.hxx

@@ -1,60 +0,0 @@
-/* -*- Mode: C++; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */
-/*
- *   Copyright 2023-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.
- */
-
-#pragma once
-
-#include "core/error_context/http.hxx"
-
-#include <cstdint>
-#include <optional>
-#include <string>
-
-namespace couchbase
-{
-class internal_manager_error_context
-{
-  public:
-    explicit internal_manager_error_context(std::error_code ec,
-                                            std::optional<std::string> last_dispatched_to,
-                                            std::optional<std::string> last_dispatched_from,
-                                            std::size_t retry_attempts,
-                                            std::set<retry_reason> retry_reasons,
-                                            std::string client_context_id,
-                                            std::uint32_t http_status,
-                                            std::string content,
-                                            std::string path);
-    internal_manager_error_context(internal_manager_error_context&& other) noexcept;
-    internal_manager_error_context& operator=(internal_manager_error_context&& other) noexcept;
-    internal_manager_error_context(const internal_manager_error_context& other) = delete;
-    internal_manager_error_context& operator=(const internal_manager_error_context& other) = delete;
-
-    [[nodiscard]] auto path() const -> const std::string&;
-    [[nodiscard]] auto content() const -> const std::string&;
-    [[nodiscard]] auto client_context_id() const -> const std::string&;
-    [[nodiscard]] auto http_status() const -> std::uint32_t;
-
-    [[nodiscard]] auto ec() const -> std::error_code;
-    [[nodiscard]] auto last_dispatched_to() const -> const std::optional<std::string>&;
-    [[nodiscard]] auto last_dispatched_from() const -> const std::optional<std::string>&;
-    [[nodiscard]] auto retry_attempts() const -> std::size_t;
-    [[nodiscard]] auto retry_reasons() const -> const std::set<retry_reason>&;
-    [[nodiscard]] auto retried_because_of(retry_reason reason) const -> bool;
-
-  private:
-    core::error_context::http ctx_;
-};
-} // namespace couchbase

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

@@ -1,100 +0,0 @@
-/* -*- Mode: C++; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */
-/*
- *   Copyright 2023-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 "internal_manager_error_context.hxx"
-
-#include <couchbase/manager_error_context.hxx>
-
-namespace couchbase
-{
-manager_error_context::manager_error_context()
-  : internal_{ nullptr }
-{
-}
-
-manager_error_context::manager_error_context(internal_manager_error_context ctx)
-  : internal_{ std::make_unique<internal_manager_error_context>(std::move(ctx)) }
-{
-}
-
-manager_error_context::manager_error_context(manager_error_context&& other) = default;
-
-manager_error_context&
-manager_error_context::operator=(manager_error_context&& other) = default;
-
-manager_error_context::~manager_error_context() = default;
-
-auto
-manager_error_context::ec() const -> std::error_code
-{
-    return internal_->ec();
-}
-
-auto
-manager_error_context::last_dispatched_from() const -> const std::optional<std::string>&
-{
-    return internal_->last_dispatched_from();
-}
-
-auto
-manager_error_context::last_dispatched_to() const -> const std::optional<std::string>&
-{
-    return internal_->last_dispatched_to();
-}
-
-auto
-manager_error_context::retry_attempts() const -> std::size_t
-{
-    return internal_->retry_attempts();
-}
-
-auto
-manager_error_context::retry_reasons() const -> const std::set<retry_reason>&
-{
-    return internal_->retry_reasons();
-}
-
-auto
-manager_error_context::retried_because_of(couchbase::retry_reason reason) const -> bool
-{
-    return internal_->retried_because_of(reason);
-}
-
-auto
-manager_error_context::path() const -> const std::string&
-{
-    return internal_->path();
-}
-
-auto
-manager_error_context::content() const -> const std::string&
-{
-    return internal_->content();
-}
-
-auto
-manager_error_context::client_context_id() const -> const std::string&
-{
-    return internal_->client_context_id();
-}
-
-auto
-manager_error_context::http_status() const -> std::uint32_t
-{
-    return internal_->http_status();
-}
-} // namespace couchbase

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

@@ -1,147 +0,0 @@
-/* -*- Mode: C++; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */
-/*
- *   Copyright 2023-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 "internal_search_error_context.hxx"
-
-#include <couchbase/search_error_context.hxx>
-
-namespace couchbase
-{
-search_error_context::search_error_context()
-  : internal_{ nullptr }
-{
-}
-
-search_error_context::search_error_context(internal_search_error_context ctx)
-  : internal_{ std::make_unique<internal_search_error_context>(std::move(ctx)) }
-{
-}
-
-search_error_context::search_error_context(search_error_context&& other) = default;
-
-search_error_context&
-search_error_context::operator=(search_error_context&& other) = default;
-
-search_error_context::~search_error_context() = default;
-
-auto
-search_error_context::ec() const -> std::error_code
-{
-    return internal_->ec();
-}
-
-auto
-search_error_context::last_dispatched_to() const -> const std::optional<std::string>&
-{
-    return internal_->last_dispatched_to();
-}
-
-auto
-search_error_context::last_dispatched_from() const -> const std::optional<std::string>&
-{
-    return internal_->last_dispatched_from();
-}
-
-auto
-search_error_context::retry_attempts() const -> std::size_t
-{
-    return internal_->retry_attempts();
-}
-
-auto
-search_error_context::retry_reasons() const -> const std::set<retry_reason>&
-{
-    return internal_->retry_reasons();
-}
-
-auto
-search_error_context::retried_because_of(retry_reason reason) const -> bool
-{
-    return internal_->retried_because_of(reason);
-}
-
-auto
-search_error_context::index_name() const -> const std::string&
-{
-    return internal_->index_name();
-}
-
-auto
-search_error_context::client_context_id() const -> const std::string&
-{
-    return internal_->client_context_id();
-}
-
-auto
-search_error_context::query() const -> const std::string&
-{
-    return internal_->query();
-}
-
-auto
-search_error_context::parameters() const -> const std::optional<std::string>&
-{
-    return internal_->parameters();
-}
-
-auto
-search_error_context::method() const -> const std::string&
-{
-    return internal_->method();
-}
-
-auto
-search_error_context::path() const -> const std::string&
-{
-    return internal_->path();
-}
-
-auto
-search_error_context::http_status() const -> std::uint32_t
-{
-    return internal_->http_status();
-}
-
-auto
-search_error_context::http_body() const -> const std::string&
-{
-    return internal_->http_body();
-}
-
-auto
-search_error_context::hostname() const -> const std::string&
-{
-    return internal_->hostname();
-}
-
-auto
-search_error_context::port() const -> std::uint16_t
-{
-    return internal_->port();
-}
-auto
-search_error_context::error() const -> const std::string&
-{
-    return internal_->error();
-}
-
-auto
-search_error_context::status() const -> const std::string&
-{
-    return internal_->status();
-}
-} // namespace couchbase