couchbase 4.1.2 → 4.1.3

package/deps/couchbase-transactions-cxx/src/transactions/attempt_context_impl.hxx

@@ -54,7 +54,7 @@ namespace transactions
     {
       private:
         transaction_context& overall_;
-        std::optional<couchbase::document_id> atr_id_;
+        std::optional<core::document_id> atr_id_;
         bool is_done_;
         std::unique_ptr<staged_mutation_queue> staged_mutations_;
         attempt_context_testing_hooks& hooks_;
@@ -69,17 +69,17 @@ namespace transactions
         // transaction_context needs access to the two functions below
         friend class transaction_context;
 
-        virtual transaction_get_result insert_raw(const couchbase::document_id& id, const std::string& content);
-        virtual void insert_raw(const couchbase::document_id& id, const std::string& content, Callback&& cb);
+        virtual transaction_get_result insert_raw(const core::document_id& id, const std::string& content);
+        virtual void insert_raw(const core::document_id& id, const std::string& content, Callback&& cb);
 
         virtual transaction_get_result replace_raw(const transaction_get_result& document, const std::string& content);
         virtual void replace_raw(const transaction_get_result& document, const std::string& content, Callback&& cb);
 
-        void remove_staged_insert(const couchbase::document_id& id, VoidCallback&& cb);
+        void remove_staged_insert(const core::document_id& id, VoidCallback&& cb);
 
         // These are all just stubs for now
-        void get_with_query(const couchbase::document_id& id, bool optional, Callback&& cb);
-        void insert_raw_with_query(const couchbase::document_id& id, const std::string& content, Callback&& cb);
+        void get_with_query(const core::document_id& id, bool optional, Callback&& cb);
+        void insert_raw_with_query(const core::document_id& id, const std::string& content, Callback&& cb);
         void replace_raw_with_query(const transaction_get_result& document, const std::string& content, Callback&& cb);
         void remove_with_query(const transaction_get_result& document, VoidCallback&& cb);
 
@@ -90,14 +90,14 @@ namespace transactions
         void query_begin_work(Handler&& cb);
 
         void do_query(const std::string& statement, const transaction_query_options& opts, QueryCallback&& cb);
-        std::exception_ptr handle_query_error(const couchbase::operations::query_response& resp);
+        std::exception_ptr handle_query_error(const core::operations::query_response& resp);
         void wrap_query(const std::string& statement,
                         const transaction_query_options& opts,
-                        const std::vector<json_string>& params,
+                        const std::vector<core::json_string>& params,
                         const nlohmann::json& txdata,
                         const std::string& hook_point,
                         bool check_expiry,
-                        std::function<void(std::exception_ptr, couchbase::operations::query_response)>&& cb);
+                        std::function<void(std::exception_ptr, core::operations::query_response)>&& cb);
 
         void handle_err_from_callback(std::exception_ptr e)
         {
@@ -281,23 +281,23 @@ namespace transactions
             txn_log->error(attempt_format_string + fmt, this->transaction_id(), this->id(), args...);
         }
 
-        cluster& cluster_ref();
+        core::cluster& cluster_ref();
 
       public:
         attempt_context_impl(transaction_context& transaction_ctx);
         ~attempt_context_impl();
 
-        virtual transaction_get_result get(const couchbase::document_id& id);
-        virtual void get(const couchbase::document_id& id, Callback&& cb);
+        virtual transaction_get_result get(const core::document_id& id);
+        virtual void get(const core::document_id& id, Callback&& cb);
 
-        virtual std::optional<transaction_get_result> get_optional(const couchbase::document_id& id);
-        virtual void get_optional(const couchbase::document_id& id, Callback&& cb);
+        virtual std::optional<transaction_get_result> get_optional(const core::document_id& id);
+        virtual void get_optional(const core::document_id& id, Callback&& cb);
 
         virtual void remove(const transaction_get_result& document);
         virtual void remove(const transaction_get_result& document, VoidCallback&& cb);
 
         virtual void query(const std::string& statement, const transaction_query_options& opts, QueryCallback&& cb);
-        virtual operations::query_response query(const std::string& statement, const transaction_query_options& opts);
+        virtual core::operations::query_response query(const std::string& statement, const transaction_query_options& opts);
 
         virtual void commit();
         virtual void commit(VoidCallback&& cb);
@@ -366,11 +366,11 @@ namespace transactions
         void check_expiry_during_commit_or_rollback(const std::string& stage, std::optional<const std::string> doc_id);
 
         template<typename Handler>
-        void set_atr_pending_locked(const couchbase::document_id& collection, std::unique_lock<std::mutex>&& lock, Handler&& cb);
+        void set_atr_pending_locked(const core::document_id& collection, std::unique_lock<std::mutex>&& lock, Handler&& cb);
 
         std::optional<error_class> error_if_expired_and_not_in_overtime(const std::string& stage, std::optional<const std::string> doc_id);
 
-        staged_mutation* check_for_own_write(const couchbase::document_id& id);
+        staged_mutation* check_for_own_write(const core::document_id& id);
 
         template<typename Handler>
         void check_and_handle_blocking_transactions(const transaction_get_result& doc, forward_compat_stage stage, Handler&& cb);
@@ -391,29 +391,29 @@ namespace transactions
 
         void atr_rollback_complete();
 
-        void select_atr_if_needed_unlocked(const couchbase::document_id& id,
+        void select_atr_if_needed_unlocked(const core::document_id& id,
                                            std::function<void(std::optional<transaction_operation_failed>)>&& cb);
 
         template<typename Handler>
-        void do_get(const couchbase::document_id& id, const std::optional<std::string> resolving_missing_atr_entry, Handler&& cb);
+        void do_get(const core::document_id& id, const std::optional<std::string> resolving_missing_atr_entry, Handler&& cb);
 
         void get_doc(
-          const couchbase::document_id& id,
+          const core::document_id& id,
           std::function<void(std::optional<error_class>, std::optional<std::string>, std::optional<transaction_get_result>)>&& cb);
 
-        couchbase::operations::mutate_in_request create_staging_request(const couchbase::document_id& in,
-                                                                        const transaction_get_result* document,
-                                                                        const std::string type,
-                                                                        std::optional<std::string> content = std::nullopt);
+        core::operations::mutate_in_request create_staging_request(const core::document_id& in,
+                                                                   const transaction_get_result* document,
+                                                                   const std::string type,
+                                                                   std::optional<std::string> content = std::nullopt);
 
         template<typename Handler, typename Delay>
-        void create_staged_insert(const couchbase::document_id& id, const std::string& content, uint64_t cas, Delay&& delay, Handler&& cb);
+        void create_staged_insert(const core::document_id& id, const std::string& content, uint64_t cas, Delay&& delay, Handler&& cb);
 
         template<typename Handler>
         void create_staged_replace(const transaction_get_result& document, const std::string& content, Handler&& cb);
 
         template<typename Handler, typename Delay>
-        void create_staged_insert_error_handler(const couchbase::document_id& id,
+        void create_staged_insert_error_handler(const core::document_id& id,
                                                 const std::string& content,
                                                 uint64_t cas,
                                                 Delay&& delay,

package/deps/couchbase-transactions-cxx/src/transactions/binary_utils.cxx

@@ -0,0 +1,28 @@
+/*
+ *     Copyright 2021 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 "binary_utils.hxx"
+
+namespace couchbase
+{
+namespace transactions
+{
+    std::string to_string(const std::vector<std::byte>& input)
+    {
+        return std::string(reinterpret_cast<const char*>(input.data()), input.size());
+    }
+} // namespace transactions
+} // namespace couchbase

package/deps/couchbase-transactions-cxx/src/transactions/binary_utils.hxx

@@ -0,0 +1,30 @@
+/*
+ *     Copyright 2021 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 <string>
+#include <vector>
+
+namespace couchbase
+{
+namespace transactions
+{
+    /*
+     * FIXME: will be removed once we migrate to taocpp/json which can parse array's of bytes directly
+     */
+    std::string to_string(const std::vector<std::byte>& input);
+} // namespace transactions
+} // namespace couchbase

package/deps/couchbase-transactions-cxx/src/transactions/exceptions.cxx

@@ -16,7 +16,7 @@
 #include "couchbase/transactions/internal/exceptions_internal.hxx"
 #include "couchbase/transactions/internal/transaction_context.hxx"
 
-#include <couchbase/errors.hxx>
+#include <couchbase/error_codes.hxx>
 #include <couchbase/transactions/exceptions.hxx>
 
 namespace couchbase
@@ -40,31 +40,30 @@ namespace transactions
         subdoc_result::status_type subdoc_status = res.subdoc_status();
         assert(res.ec || (!res.ignore_subdoc_errors && subdoc_status != subdoc_result::status_type::success));
         if (res.ec || res.ignore_subdoc_errors) {
-            if (res.ec == couchbase::error::key_value_errc::document_not_found) {
+            if (res.ec == couchbase::errc::key_value::document_not_found) {
                 return FAIL_DOC_NOT_FOUND;
             }
-            if (res.ec == couchbase::error::key_value_errc::document_exists) {
+            if (res.ec == couchbase::errc::key_value::document_exists) {
                 return FAIL_DOC_ALREADY_EXISTS;
             }
-            if (res.ec == couchbase::error::common_errc::cas_mismatch) {
+            if (res.ec == couchbase::errc::common::cas_mismatch) {
                 return FAIL_CAS_MISMATCH;
             }
-            if (res.ec == couchbase::error::key_value_errc::value_too_large) {
+            if (res.ec == couchbase::errc::key_value::value_too_large) {
                 return FAIL_ATR_FULL;
             }
-            if (res.ec == couchbase::error::common_errc::unambiguous_timeout ||
-                res.ec == couchbase::error::common_errc::temporary_failure ||
-                res.ec == couchbase::error::key_value_errc::durable_write_in_progress) {
+            if (res.ec == couchbase::errc::common::unambiguous_timeout || res.ec == couchbase::errc::common::temporary_failure ||
+                res.ec == couchbase::errc::key_value::durable_write_in_progress) {
                 return FAIL_TRANSIENT;
             }
-            if (res.ec == couchbase::error::key_value_errc::durability_ambiguous ||
-                res.ec == couchbase::error::common_errc::ambiguous_timeout || res.ec == couchbase::error::common_errc::request_canceled) {
+            if (res.ec == couchbase::errc::key_value::durability_ambiguous || res.ec == couchbase::errc::common::ambiguous_timeout ||
+                res.ec == couchbase::errc::common::request_canceled) {
                 return FAIL_AMBIGUOUS;
             }
-            if (res.ec == couchbase::error::key_value_errc::path_not_found) {
+            if (res.ec == couchbase::errc::key_value::path_not_found) {
                 return FAIL_PATH_NOT_FOUND;
             }
-            if (res.ec == couchbase::error::key_value_errc::path_exists) {
+            if (res.ec == couchbase::errc::key_value::path_exists) {
                 return FAIL_PATH_ALREADY_EXISTS;
             }
             return FAIL_OTHER;

package/deps/couchbase-transactions-cxx/src/transactions/logging.cxx

@@ -48,28 +48,28 @@ namespace transactions
 
     // TODO: better integration with client, so we don't need to repeat this private
     // method.
-    spdlog::level::level_enum translate_level(couchbase::logger::level level)
+    spdlog::level::level_enum translate_level(core::logger::level level)
     {
         switch (level) {
-            case couchbase::logger::level::trace:
+            case core::logger::level::trace:
                 return spdlog::level::level_enum::trace;
-            case couchbase::logger::level::debug:
+            case core::logger::level::debug:
                 return spdlog::level::level_enum::debug;
-            case couchbase::logger::level::info:
+            case core::logger::level::info:
                 return spdlog::level::level_enum::info;
-            case couchbase::logger::level::warn:
+            case core::logger::level::warn:
                 return spdlog::level::level_enum::warn;
-            case couchbase::logger::level::err:
+            case core::logger::level::err:
                 return spdlog::level::level_enum::err;
-            case couchbase::logger::level::critical:
+            case core::logger::level::critical:
                 return spdlog::level::level_enum::critical;
-            case couchbase::logger::level::off:
+            case core::logger::level::off:
                 return spdlog::level::level_enum::off;
         }
         return spdlog::level::level_enum::trace;
     }
 
-    void set_transactions_log_level(couchbase::logger::level level)
+    void set_transactions_log_level(core::logger::level level)
     {
         spdlog::level::level_enum lvl = translate_level(level);
         txn_log->set_level(lvl);
@@ -81,7 +81,7 @@ namespace transactions
     // consider a mutex, but eventually we will merge with the cxx_client so
     // this will be fine for now.   Unsure if this will lead to issues if called
     // while logging is happening in other threads.  Do this once, at startup.
-    void create_loggers(couchbase::logger::level level, spdlog::sink_ptr sink)
+    void create_loggers(core::logger::level level, spdlog::sink_ptr sink)
     {
         if (nullptr != sink) {
             sink->set_level(translate_level(level));

package/deps/couchbase-transactions-cxx/src/transactions/result.cxx

@@ -15,7 +15,7 @@
  */
 
 #include "result.hxx"
-#include <couchbase/errors.hxx>
+#include <couchbase/error_codes.hxx>
 #include <couchbase/transactions/transcoder.hxx>
 #include <sstream>
 

package/deps/couchbase-transactions-cxx/src/transactions/result.hxx

@@ -16,6 +16,10 @@
 
 #pragma once
 
+#include "binary_utils.hxx"
+
+#include <core/cluster.hxx>
+#include <core/utils/json.hxx>
 #include <couchbase/internal/nlohmann/json.hpp>
 #include <couchbase/support.hxx>
 #include <couchbase/transactions/transcoder.hxx>
@@ -182,9 +186,9 @@ namespace transactions
         static result create_from_mutation_response(const Resp& resp)
         {
             result res{};
-            res.ec = resp.ctx.ec;
-            res.cas = resp.cas.value;
-            res.key = resp.ctx.id.key();
+            res.ec = resp.ctx.ec();
+            res.cas = resp.cas.value();
+            res.key = resp.ctx.id();
             return res;
         }
 
@@ -196,24 +200,40 @@ namespace transactions
             memcpy(content.data(), resp.value.data(), resp.value.size());
 
             result res{};
-            res.ec = resp.ctx.ec;
-            res.cas = resp.cas.value;
-            res.key = resp.ctx.id.key();
+            res.ec = resp.ctx.ec();
+            res.cas = resp.cas.value();
+            res.key = resp.ctx.id();
             res.flags = resp.flags;
             res.raw_value = std::move(content);
             return res;
         }
 
-        template<typename Resp>
-        static result create_from_subdoc_response(const Resp& resp)
+        static result create_from_subdoc_response(const core::operations::lookup_in_response& resp)
+        {
+            result res{};
+            res.ec = resp.ctx.ec();
+            res.cas = resp.cas.value();
+            res.key = resp.ctx.id();
+            res.is_deleted = resp.deleted;
+            for (std::size_t i = 0; i < resp.fields.size(); ++i) {
+                res.values.emplace_back(to_string(resp.fields[i].value), static_cast<uint32_t>(resp.fields[i].status));
+            }
+            return res;
+        }
+
+        static result create_from_subdoc_response(const core::operations::mutate_in_response& resp)
         {
             result res{};
-            res.ec = resp.ctx.ec;
-            res.cas = resp.cas.value;
-            res.key = resp.ctx.id.key();
+            res.ec = resp.ctx.ec();
+            res.cas = resp.cas.value();
+            res.key = resp.ctx.id();
             res.is_deleted = resp.deleted;
-            for (auto& field : resp.fields) {
-                res.values.emplace_back(field.value, static_cast<uint32_t>(field.status));
+
+            for (std::size_t i = 0; i < resp.fields.size(); ++i) {
+                auto value = resp.fields[i].value.size() > 0
+                               ? core::utils::json::generate(core::utils::json::parse_binary(resp.fields[i].value))
+                               : std::string();
+                res.values.emplace_back(value, static_cast<uint32_t>(resp.fields[i].status));
             }
             return res;
         }

package/deps/couchbase-transactions-cxx/src/transactions/staged_mutation.cxx

@@ -42,7 +42,7 @@ tx::staged_mutation_queue::add(const tx::staged_mutation& mutation)
 }
 
 void
-tx::staged_mutation_queue::extract_to(const std::string& prefix, couchbase::operations::mutate_in_request& req)
+tx::staged_mutation_queue::extract_to(const std::string& prefix, core::operations::mutate_in_request& req)
 {
     std::lock_guard<std::mutex> lock(mutex_);
     nlohmann::json inserts;
@@ -66,13 +66,23 @@ tx::staged_mutation_queue::extract_to(const std::string& prefix, couchbase::oper
                 break;
         }
     }
-    req.specs.add_spec(protocol::subdoc_opcode::dict_upsert, true, true, false, prefix + ATR_FIELD_DOCS_INSERTED, inserts.dump());
-    req.specs.add_spec(protocol::subdoc_opcode::dict_upsert, true, true, false, prefix + ATR_FIELD_DOCS_REPLACED, replaces.dump());
-    req.specs.add_spec(protocol::subdoc_opcode::dict_upsert, true, true, false, prefix + ATR_FIELD_DOCS_REMOVED, removes.dump());
+    req.specs =
+      couchbase::mutate_in_specs{
+          couchbase::mutate_in_specs::upsert_raw(prefix + ATR_FIELD_DOCS_INSERTED, core::utils::to_binary(inserts.dump()))
+            .xattr()
+            .create_path(),
+          couchbase::mutate_in_specs::upsert_raw(prefix + ATR_FIELD_DOCS_REPLACED, core::utils::to_binary(replaces.dump()))
+            .xattr()
+            .create_path(),
+          couchbase::mutate_in_specs::upsert_raw(prefix + ATR_FIELD_DOCS_REMOVED, core::utils::to_binary(removes.dump()))
+            .xattr()
+            .create_path(),
+      }
+        .specs();
 }
 
 void
-tx::staged_mutation_queue::remove_any(const couchbase::document_id& id)
+tx::staged_mutation_queue::remove_any(const core::document_id& id)
 {
     std::lock_guard<std::mutex> lock(mutex_);
     auto new_end =
@@ -81,7 +91,7 @@ tx::staged_mutation_queue::remove_any(const couchbase::document_id& id)
 }
 
 tx::staged_mutation*
-tx::staged_mutation_queue::find_any(const couchbase::document_id& id)
+tx::staged_mutation_queue::find_any(const core::document_id& id)
 {
     std::lock_guard<std::mutex> lock(mutex_);
     for (auto& item : queue_) {
@@ -93,7 +103,7 @@ tx::staged_mutation_queue::find_any(const couchbase::document_id& id)
 }
 
 tx::staged_mutation*
-tx::staged_mutation_queue::find_replace(const couchbase::document_id& id)
+tx::staged_mutation_queue::find_replace(const core::document_id& id)
 {
     std::lock_guard<std::mutex> lock(mutex_);
     for (auto& item : queue_) {
@@ -105,7 +115,7 @@ tx::staged_mutation_queue::find_replace(const couchbase::document_id& id)
 }
 
 tx::staged_mutation*
-tx::staged_mutation_queue::find_insert(const couchbase::document_id& id)
+tx::staged_mutation_queue::find_insert(const core::document_id& id)
 {
     std::lock_guard<std::mutex> lock(mutex_);
     for (auto& item : queue_) {
@@ -117,7 +127,7 @@ tx::staged_mutation_queue::find_insert(const couchbase::document_id& id)
 }
 
 tx::staged_mutation*
-tx::staged_mutation_queue::find_remove(const couchbase::document_id& id)
+tx::staged_mutation_queue::find_remove(const core::document_id& id)
 {
     std::lock_guard<std::mutex> lock(mutex_);
     for (auto& item : queue_) {
@@ -183,16 +193,19 @@ tx::staged_mutation_queue::rollback_insert(attempt_context_impl& ctx, staged_mut
         if (ec) {
             throw client_error(*ec, "before_rollback_delete_insert hook threw error");
         }
-        couchbase::operations::mutate_in_request req{ item.doc().id() };
-        req.specs.add_spec(protocol::subdoc_opcode::remove, true, TRANSACTION_INTERFACE_PREFIX_ONLY);
+        core::operations::mutate_in_request req{ item.doc().id() };
+        req.specs =
+          couchbase::mutate_in_specs{
+              couchbase::mutate_in_specs::remove(TRANSACTION_INTERFACE_PREFIX_ONLY).xattr(),
+          }
+            .specs();
         req.access_deleted = true;
-        req.cas.value = item.doc().cas();
+        req.cas = couchbase::cas(item.doc().cas());
         wrap_durable_request(req, ctx.overall_.config());
         auto barrier = std::make_shared<std::promise<result>>();
         auto f = barrier->get_future();
-        ctx.cluster_ref().execute(req, [barrier](couchbase::operations::mutate_in_response resp) {
-            barrier->set_value(result::create_from_subdoc_response(resp));
-        });
+        ctx.cluster_ref().execute(
+          req, [barrier](core::operations::mutate_in_response resp) { barrier->set_value(result::create_from_subdoc_response(resp)); });
         auto res = wrap_operation_future(f);
         ctx.trace("rollback result {}", res);
         ec = ctx.hooks_.after_rollback_delete_inserted(&ctx, item.doc().id().key());
@@ -238,15 +251,18 @@ tx::staged_mutation_queue::rollback_remove_or_replace(attempt_context_impl& ctx,
         if (ec) {
             throw client_error(*ec, "before_doc_rolled_back hook threw error");
         }
-        couchbase::operations::mutate_in_request req{ item.doc().id() };
-        req.specs.add_spec(protocol::subdoc_opcode::remove, true, TRANSACTION_INTERFACE_PREFIX_ONLY);
-        req.cas.value = item.doc().cas();
+        core::operations::mutate_in_request req{ item.doc().id() };
+        req.specs =
+          couchbase::mutate_in_specs{
+              couchbase::mutate_in_specs::remove(TRANSACTION_INTERFACE_PREFIX_ONLY).xattr(),
+          }
+            .specs();
+        req.cas = couchbase::cas(item.doc().cas());
         wrap_durable_request(req, ctx.overall_.config());
         auto barrier = std::make_shared<std::promise<result>>();
         auto f = barrier->get_future();
-        ctx.cluster_ref().execute(req, [barrier](couchbase::operations::mutate_in_response resp) {
-            barrier->set_value(result::create_from_subdoc_response(resp));
-        });
+        ctx.cluster_ref().execute(
+          req, [barrier](core::operations::mutate_in_response resp) { barrier->set_value(result::create_from_subdoc_response(resp)); });
         auto res = wrap_operation_future(f);
         ctx.trace("rollback result {}", res);
         ec = ctx.hooks_.after_rollback_replace_or_remove(&ctx, item.doc().id().key());
@@ -293,26 +309,31 @@ tx::staged_mutation_queue::commit_doc(attempt_context_impl& ctx, staged_mutation
 
             result res;
             if (item.type() == staged_mutation_type::INSERT && !cas_zero_mode) {
-                couchbase::operations::insert_request req{ item.doc().id() };
+                core::operations::insert_request req{ item.doc().id() };
                 auto content = item.doc().content<nlohmann::json>().dump();
-                req.value = couchbase::utils::to_binary(content);
+                req.value = core::utils::to_binary(content);
                 wrap_durable_request(req, ctx.overall_.config());
                 auto barrier = std::make_shared<std::promise<result>>();
                 auto f = barrier->get_future();
-                ctx.cluster_ref().execute(req, [barrier](couchbase::operations::insert_response resp) {
+                ctx.cluster_ref().execute(req, [barrier](core::operations::insert_response resp) {
                     barrier->set_value(result::create_from_mutation_response(resp));
                 });
                 res = wrap_operation_future(f);
             } else {
-                couchbase::operations::mutate_in_request req{ item.doc().id() };
-                req.specs.add_spec(protocol::subdoc_opcode::remove, true, TRANSACTION_INTERFACE_PREFIX_ONLY);
-                req.specs.add_spec(protocol::subdoc_opcode::set_doc, false, false, false, "", item.content());
-                req.store_semantics = protocol::mutate_in_request_body::store_semantics_type::replace;
-                req.cas.value = cas_zero_mode ? 0 : item.doc().cas();
+                core::operations::mutate_in_request req{ item.doc().id() };
+                req.specs =
+                  couchbase::mutate_in_specs{
+                      couchbase::mutate_in_specs::remove(TRANSACTION_INTERFACE_PREFIX_ONLY).xattr(),
+                      // subdoc::opcode::set_doc used in replace w/ empty path
+                      couchbase::mutate_in_specs::replace_raw("", core::utils::to_binary(item.content())),
+                  }
+                    .specs();
+                req.store_semantics = couchbase::store_semantics::replace;
+                req.cas = couchbase::cas(cas_zero_mode ? 0 : item.doc().cas());
                 wrap_durable_request(req, ctx.overall_.config());
                 auto barrier = std::make_shared<std::promise<result>>();
                 auto f = barrier->get_future();
-                ctx.cluster_ref().execute(req, [barrier](couchbase::operations::mutate_in_response resp) {
+                ctx.cluster_ref().execute(req, [barrier](core::operations::mutate_in_response resp) {
                     barrier->set_value(result::create_from_subdoc_response(resp));
                 });
                 res = wrap_operation_future(f);
@@ -362,13 +383,12 @@ tx::staged_mutation_queue::remove_doc(attempt_context_impl& ctx, staged_mutation
             if (ec) {
                 throw client_error(*ec, "before_doc_removed hook threw error");
             }
-            couchbase::operations::remove_request req{ item.doc().id() };
+            core::operations::remove_request req{ item.doc().id() };
             wrap_durable_request(req, ctx.overall_.config());
             auto barrier = std::make_shared<std::promise<result>>();
             auto f = barrier->get_future();
-            ctx.cluster_ref().execute(req, [barrier](couchbase::operations::remove_response resp) {
-                barrier->set_value(result::create_from_mutation_response(resp));
-            });
+            ctx.cluster_ref().execute(
+              req, [barrier](core::operations::remove_response resp) { barrier->set_value(result::create_from_mutation_response(resp)); });
             wrap_operation_future(f);
             ec = ctx.hooks_.after_doc_removed_pre_retry(&ctx, item.doc().id().key());
             if (ec) {

package/deps/couchbase-transactions-cxx/src/transactions/staged_mutation.hxx

@@ -56,7 +56,7 @@ namespace transactions
             return *this;
         }
 
-        CB_NODISCARD const couchbase::document_id& id() const
+        CB_NODISCARD const core::document_id& id() const
         {
             return doc_.id();
         }
@@ -116,16 +116,16 @@ namespace transactions
       public:
         bool empty();
         void add(const staged_mutation& mutation);
-        void extract_to(const std::string& prefix, couchbase::operations::mutate_in_request& req);
+        void extract_to(const std::string& prefix, core::operations::mutate_in_request& req);
         void commit(attempt_context_impl& ctx);
         void rollback(attempt_context_impl& ctx);
         void iterate(std::function<void(staged_mutation&)>);
-        void remove_any(const couchbase::document_id& id);
+        void remove_any(const core::document_id&);
 
-        staged_mutation* find_any(const couchbase::document_id& id);
-        staged_mutation* find_replace(const couchbase::document_id& id);
-        staged_mutation* find_insert(const couchbase::document_id& id);
-        staged_mutation* find_remove(const couchbase::document_id& id);
+        staged_mutation* find_any(const core::document_id& id);
+        staged_mutation* find_replace(const core::document_id& id);
+        staged_mutation* find_insert(const core::document_id& id);
+        staged_mutation* find_remove(const core::document_id& id);
     };
 } // namespace transactions
 } // namespace couchbase

package/deps/couchbase-transactions-cxx/src/transactions/transaction_config.cxx

@@ -31,7 +31,7 @@ namespace transactions
       , cleanup_client_attempts_(true)
       , attempt_context_hooks_(new attempt_context_testing_hooks())
       , cleanup_hooks_(new cleanup_testing_hooks())
-      , scan_consistency_(couchbase::query_scan_consistency::request_plus)
+      , scan_consistency_(core::query_scan_consistency::request_plus)
     {
     }
 

package/deps/couchbase-transactions-cxx/src/transactions/transaction_context.cxx

@@ -100,7 +100,7 @@ namespace transactions
         return current_attempt_context_;
     }
 
-    void transaction_context::get(const couchbase::document_id& id, async_attempt_context::Callback&& cb)
+    void transaction_context::get(const core::document_id& id, async_attempt_context::Callback&& cb)
     {
         if (current_attempt_context_) {
             return current_attempt_context_->get(id, std::move(cb));
@@ -108,7 +108,7 @@ namespace transactions
         throw transaction_operation_failed(FAIL_OTHER, "no current attempt context");
     }
 
-    void transaction_context::get_optional(const couchbase::document_id& id, async_attempt_context::Callback&& cb)
+    void transaction_context::get_optional(const core::document_id& id, async_attempt_context::Callback&& cb)
     {
         if (current_attempt_context_) {
             return current_attempt_context_->get_optional(id, std::move(cb));
@@ -116,7 +116,7 @@ namespace transactions
         throw transaction_operation_failed(FAIL_OTHER, "no current attempt context");
     }
 
-    void transaction_context::insert(const couchbase::document_id& id, const std::string& content, async_attempt_context::Callback&& cb)
+    void transaction_context::insert(const core::document_id& id, const std::string& content, async_attempt_context::Callback&& cb)
     {
         if (current_attempt_context_) {
             return current_attempt_context_->insert_raw(id, content, std::move(cb));