couchbase 4.1.1 → 4.1.2

package/deps/couchbase-transactions-cxx/deps/couchbase-cxx-client/couchbase/operations/http_noop.cxx

@@ -26,6 +26,7 @@ http_noop_request::encode_to(http_noop_request::encoded_request_type& encoded, h
 {
     encoded.headers["connection"] = "keep-alive";
     encoded.method = "GET";
+    encoded.path = "/";
     switch (type) {
         case service_type::query:
             timeout = timeout_defaults::query_timeout;
@@ -41,11 +42,14 @@ http_noop_request::encode_to(http_noop_request::encoded_request_type& encoded, h
             break;
         case service_type::view:
             timeout = timeout_defaults::view_timeout;
-            encoded.path = "/";
             break;
         case service_type::management:
-        case service_type::key_value:
+            timeout = timeout_defaults::management_timeout;
+            break;
         case service_type::eventing:
+            timeout = timeout_defaults::eventing_timeout;
+            break;
+        case service_type::key_value:
             return error::common_errc::feature_not_available;
     }
     return {};

package/deps/couchbase-transactions-cxx/deps/couchbase-cxx-client/couchbase/operations/management/analytics_dataset_get_all.cxx

@@ -27,7 +27,7 @@ std::error_code
 analytics_dataset_get_all_request::encode_to(encoded_request_type& encoded, http_context& /* context */) const
 {
     tao::json::value body{
-        { "statement", "SELECT d.* FROM Metadata.`Dataset` d WHERE d.DataverseName <> \"Metadata\"" },
+        { "statement", R"(SELECT d.* FROM Metadata.`Dataset` d WHERE d.DataverseName <> "Metadata" AND d.DatasetType = "INTERNAL")" },
     };
     encoded.headers["content-type"] = "application/json";
     encoded.method = "POST";
@@ -63,8 +63,7 @@ analytics_dataset_get_all_request::make_response(error_context::http&& ctx, cons
             response.ctx.ec = extract_common_error_code(encoded.status_code, encoded.body.data());
             return response;
         }
-        auto* results = payload.find("results");
-        if (results != nullptr && results->is_array()) {
+        if (auto* results = payload.find("results"); results != nullptr && results->is_array()) {
             for (const auto& res : results->get_array()) {
                 couchbase::management::analytics::dataset ds;
                 ds.name = res.at("DatasetName").get_string();

package/deps/couchbase-transactions-cxx/deps/couchbase-cxx-client/couchbase/operations/management/analytics_get_pending_mutations.cxx

@@ -47,7 +47,7 @@ analytics_get_pending_mutations_request::make_response(error_context::http&& ctx
             if (payload.is_object()) {
                 for (const auto& [dataverse, entry] : payload.get_object()) {
                     for (const auto& [dataset, counter] : entry.get_object()) {
-                        response.stats.try_emplace(fmt::format("{}.{}", dataverse, dataset), counter.get_unsigned());
+                        response.stats.try_emplace(fmt::format("{}.{}", dataverse, dataset), counter.as<std::int64_t>());
                     }
                 }
             }

package/deps/couchbase-transactions-cxx/deps/couchbase-cxx-client/couchbase/operations/management/analytics_get_pending_mutations.hxx

@@ -30,7 +30,7 @@ struct analytics_get_pending_mutations_response {
     error_context::http ctx;
     std::string status{};
     std::vector<analytics_problem> errors{};
-    std::map<std::string, std::uint64_t> stats{};
+    std::map<std::string, std::int64_t> stats{};
 };
 
 struct analytics_get_pending_mutations_request {

package/deps/couchbase-transactions-cxx/deps/couchbase-cxx-client/couchbase/operations/management/analytics_link_get_all.cxx

@@ -95,8 +95,7 @@ analytics_link_get_all_request::make_response(error_context::http&& ctx, const e
             }
         } else if (payload.is_array()) {
             for (const auto& link : payload.get_array()) {
-                const std::string& type_ = link.at("type").get_string();
-                if (type_ == "couchbase") {
+                if (const std::string& type_ = link.at("type").get_string(); type_ == "couchbase") {
                     response.couchbase.emplace_back(link.as<couchbase::management::analytics::couchbase_remote_link>());
                 } else if (type_ == "s3") {
                     response.s3.emplace_back(link.as<couchbase::management::analytics::s3_external_link>());

package/deps/couchbase-transactions-cxx/deps/couchbase-cxx-client/couchbase/operations/management/error_utils.cxx

@@ -155,31 +155,33 @@ translate_query_error_code(std::uint64_t error, const std::string& message, std:
             return error::query_errc::prepared_statement_failure;
 
         case 12009: /* IKey: "datastore.couchbase.DML_error" */
+        {
             if (message.find("CAS mismatch") != std::string::npos) {
                 return error::common_errc::cas_mismatch;
-            } else {
-                switch (reason) {
-                    case 12033:
-                        return error::common_errc::cas_mismatch;
-                    case 17014:
-                        return error::key_value_errc::document_not_found;
-                    case 17012:
-                        return error::key_value_errc::document_exists;
-                    default:
-                        return error::query_errc::dml_failure;
-                }
             }
+            switch (reason) {
+                case 12033:
+                    return error::common_errc::cas_mismatch;
+                case 17014:
+                    return error::key_value_errc::document_not_found;
+                case 17012:
+                    return error::key_value_errc::document_exists;
+                default:
+                    return error::query_errc::dml_failure;
+            }
+        }
 
         case 13014: /* IKey: "datastore.couchbase.insufficient_credentials" */
             return error::common_errc::authentication_failure;
 
-        default:
+        default: {
             if ((error >= 12000 && error < 13000) || (error >= 14000 && error < 15000)) {
                 return error::query_errc::index_failure;
-            } else if (error >= 4000 && error < 5000) {
+            }
+            if (error >= 4000 && error < 5000) {
                 return error::query_errc::planning_failure;
             }
-            break;
+        } break;
     }
     return extract_common_query_error_code(error, message);
 }

package/deps/couchbase-transactions-cxx/deps/couchbase-cxx-client/couchbase/operations/management/query_index_drop.cxx

@@ -39,13 +39,14 @@ query_index_drop_request::encode_to(encoded_request_type& encoded, http_context&
     }
 
     std::string drop_index_stmt;
-    if (!scope_name.empty() || !collection_name.empty()) {
+    if (is_primary && index_name.empty()) {
+        drop_index_stmt = fmt::format(R"(DROP PRIMARY INDEX ON {} USING GSI)", keyspace);
+    } else if (!scope_name.empty() || !collection_name.empty()) {
         drop_index_stmt = fmt::format(R"(DROP INDEX `{}` ON {} USING GSI)", index_name, keyspace);
     } else {
         drop_index_stmt = fmt::format(R"(DROP INDEX {}.`{}` USING GSI)", keyspace, index_name);
     }
-    tao::json::value body{ { "statement", is_primary ? fmt::format(R"(DROP PRIMARY INDEX ON {} USING GSI)", keyspace) : drop_index_stmt },
-                           { "client_context_id", encoded.client_context_id } };
+    tao::json::value body{ { "statement", drop_index_stmt }, { "client_context_id", encoded.client_context_id } };
     encoded.method = "POST";
     encoded.path = "/query/service";
     encoded.body = utils::json::generate(body);

package/deps/couchbase-transactions-cxx/deps/couchbase-cxx-client/couchbase/origin.hxx

@@ -118,6 +118,16 @@ struct origin {
         return credentials_.key_path;
     }
 
+    [[nodiscard]] std::vector<std::string> get_hostnames() const
+    {
+        std::vector<std::string> res;
+        res.reserve(nodes_.size());
+        for (const auto& [hostname, _] : nodes_) {
+            res.emplace_back(hostname);
+        }
+        return res;
+    }
+
     [[nodiscard]] std::vector<std::string> get_nodes() const
     {
         std::vector<std::string> res;

package/deps/couchbase-transactions-cxx/deps/couchbase-cxx-client/couchbase/platform/string_hex.cc

@@ -28,9 +28,11 @@ from_hex_digit(char c)
 {
     if ('0' <= c && c <= '9') {
         return static_cast<uint8_t>(c - '0');
-    } else if ('A' <= c && c <= 'F') {
+    }
+    if ('A' <= c && c <= 'F') {
         return static_cast<uint8_t>(c + 10 - 'A');
-    } else if ('a' <= c && c <= 'f') {
+    }
+    if ('a' <= c && c <= 'f') {
         return static_cast<uint8_t>(c + 10 - 'a');
     }
     throw std::invalid_argument("couchbase::from_hex_digit: character was not in hexadecimal range");

package/deps/couchbase-transactions-cxx/deps/couchbase-cxx-client/couchbase/protocol/CMakeLists.txt

@@ -30,6 +30,7 @@ add_library(
   cmd_touch.cxx
   cmd_unlock.cxx
   cmd_upsert.cxx
+  frame_info_utils.cxx
   status.cxx)
 set_target_properties(couchbase_protocol PROPERTIES POSITION_INDEPENDENT_CODE ON)
 target_link_libraries(

package/deps/couchbase-transactions-cxx/deps/couchbase-cxx-client/couchbase/protocol/client_opcode.hxx

@@ -253,7 +253,7 @@ enum class subdoc_opcode : uint8_t {
 constexpr bool
 is_valid_client_opcode(uint8_t code)
 {
-    switch (client_opcode(code)) {
+    switch (static_cast<client_opcode>(code)) {
         case client_opcode::get:
         case client_opcode::upsert:
         case client_opcode::insert:
@@ -332,7 +332,7 @@ is_valid_client_opcode(uint8_t code)
 constexpr bool
 is_valid_subdoc_opcode(uint8_t code)
 {
-    switch (subdoc_opcode(code)) {
+    switch (static_cast<subdoc_opcode>(code)) {
         case subdoc_opcode::get:
         case subdoc_opcode::exists:
         case subdoc_opcode::dict_add:
@@ -354,6 +354,6 @@ is_valid_subdoc_opcode(uint8_t code)
     return false;
 }
 
-const inline static std::vector<std::uint8_t> empty_buffer;
+const inline static std::vector<std::byte> empty_buffer;
 const inline static std::string empty_string;
 } // namespace couchbase::protocol

package/deps/couchbase-transactions-cxx/deps/couchbase-cxx-client/couchbase/protocol/client_request.cxx

@@ -16,20 +16,21 @@
  */
 
 #include <couchbase/protocol/client_request.hxx>
+#include <couchbase/utils/binary.hxx>
 
 #include <snappy.h>
 
 namespace couchbase::protocol
 {
 std::pair<bool, std::uint32_t>
-compress_value(const std::vector<std::uint8_t>& value, std::vector<uint8_t>::iterator& output)
+compress_value(const std::vector<std::byte>& value, std::vector<std::byte>::iterator& output)
 {
     static const double min_ratio = 0.83;
 
     std::string compressed;
     std::size_t compressed_size = snappy::Compress(reinterpret_cast<const char*>(value.data()), value.size(), &compressed);
     if (gsl::narrow_cast<double>(compressed_size) / gsl::narrow_cast<double>(value.size()) < min_ratio) {
-        std::copy(compressed.begin(), compressed.end(), output);
+        utils::to_binary(compressed, output);
         return { true, gsl::narrow_cast<std::uint32_t>(compressed_size) };
     }
     return { false, 0 };

package/deps/couchbase-transactions-cxx/deps/couchbase-cxx-client/couchbase/protocol/client_request.hxx

@@ -20,15 +20,17 @@
 #include <couchbase/protocol/client_opcode.hxx>
 #include <couchbase/protocol/client_response.hxx>
 #include <couchbase/protocol/magic.hxx>
+#include <couchbase/utils/binary.hxx>
 #include <couchbase/utils/byteswap.hxx>
 
+#include <algorithm>
 #include <cstring>
 #include <gsl/util>
 
 namespace couchbase::protocol
 {
 std::pair<bool, std::uint32_t>
-compress_value(const std::vector<std::uint8_t>& value, std::vector<std::uint8_t>::iterator& output);
+compress_value(const std::vector<std::byte>& value, std::vector<std::byte>::iterator& output);
 
 template<typename Body>
 class client_request
@@ -46,7 +48,6 @@ class client_request
     std::uint32_t opaque_{ 0 };
     std::uint64_t cas_{ 0 };
     Body body_;
-    std::vector<std::uint8_t> payload_;
 
   public:
     [[nodiscard]] client_opcode opcode() const
@@ -84,74 +85,73 @@ class client_request
         return body_;
     }
 
-    std::vector<std::uint8_t>& data(bool try_to_compress = false)
+    [[nodiscard]] std::vector<std::byte> data(bool try_to_compress = false)
     {
         switch (opcode_) {
             case protocol::client_opcode::insert:
             case protocol::client_opcode::upsert:
             case protocol::client_opcode::replace:
-                write_payload(try_to_compress);
-                break;
+                return generate_payload(try_to_compress);
             default:
-                write_payload(false);
                 break;
         }
-        return payload_;
+        return generate_payload(false);
     }
 
   private:
-    void write_payload(bool try_to_compress)
+    [[nodiscard]] std::vector<std::byte> generate_payload(bool try_to_compress)
     {
-        payload_.resize(header_size + body_.size(), 0);
-        payload_[0] = static_cast<uint8_t>(magic_);
-        payload_[1] = static_cast<uint8_t>(opcode_);
+        std::vector<std::byte> payload;
+        payload.resize(header_size + body_.size(), std::byte{ 0 });
+        payload[0] = static_cast<std::byte>(magic_);
+        payload[1] = static_cast<std::byte>(opcode_);
 
-        auto framing_extras = body_.framing_extras();
+        const auto& framing_extras = body_.framing_extras();
 
         uint16_t key_size = gsl::narrow_cast<uint16_t>(body_.key().size());
         if (framing_extras.size() == 0) {
             key_size = utils::byte_swap(key_size);
-            memcpy(payload_.data() + 2, &key_size, sizeof(key_size));
+            memcpy(payload.data() + 2, &key_size, sizeof(key_size));
         } else {
             magic_ = protocol::magic::alt_client_request;
-            payload_[0] = static_cast<uint8_t>(magic_);
-            payload_[2] = gsl::narrow_cast<std::uint8_t>(framing_extras.size());
-            payload_[3] = gsl::narrow_cast<std::uint8_t>(key_size);
+            payload[0] = static_cast<std::byte>(magic_);
+            payload[2] = gsl::narrow_cast<std::byte>(framing_extras.size());
+            payload[3] = gsl::narrow_cast<std::byte>(key_size);
         }
 
         uint8_t ext_size = gsl::narrow_cast<uint8_t>(body_.extras().size());
-        memcpy(payload_.data() + 4, &ext_size, sizeof(ext_size));
+        memcpy(payload.data() + 4, &ext_size, sizeof(ext_size));
 
         uint16_t vbucket = utils::byte_swap(gsl::narrow_cast<uint16_t>(partition_));
-        memcpy(payload_.data() + 6, &vbucket, sizeof(vbucket));
+        memcpy(payload.data() + 6, &vbucket, sizeof(vbucket));
 
         uint32_t body_size = utils::byte_swap(gsl::narrow_cast<uint32_t>(body_.size()));
-        memcpy(payload_.data() + 8, &body_size, sizeof(body_size));
+        memcpy(payload.data() + 8, &body_size, sizeof(body_size));
 
-        memcpy(payload_.data() + 12, &opaque_, sizeof(opaque_));
-        memcpy(payload_.data() + 16, &cas_, sizeof(cas_));
+        memcpy(payload.data() + 12, &opaque_, sizeof(opaque_));
+        memcpy(payload.data() + 16, &cas_, sizeof(cas_));
 
-        auto body_itr = payload_.begin() + header_size;
+        auto body_itr = payload.begin() + header_size;
         if (framing_extras.size() > 0) {
             body_itr = std::copy(framing_extras.begin(), framing_extras.end(), body_itr);
         }
         body_itr = std::copy(body_.extras().begin(), body_.extras().end(), body_itr);
-        body_itr = std::copy(body_.key().begin(), body_.key().end(), body_itr);
+        body_itr = utils::to_binary(body_.key(), body_itr);
 
-        static const std::size_t min_size_to_compress = 32;
-        if (try_to_compress && body_.value().size() > min_size_to_compress) {
+        if (static const std::size_t min_size_to_compress = 32; try_to_compress && body_.value().size() > min_size_to_compress) {
             if (auto [compressed, new_value_size] = compress_value(body_.value(), body_itr); compressed) {
                 /* the compressed value meets requirements and was copied to the payload */
-                payload_[5] |= static_cast<std::uint8_t>(protocol::datatype::snappy);
+                payload[5] |= static_cast<std::byte>(protocol::datatype::snappy);
                 std::uint32_t new_body_size =
                   utils::byte_swap(body_size) - gsl::narrow_cast<std::uint32_t>(body_.value().size()) + new_value_size;
-                payload_.resize(header_size + new_body_size);
+                payload.resize(header_size + new_body_size);
                 new_body_size = utils::byte_swap(new_body_size);
-                memcpy(payload_.data() + 8, &new_body_size, sizeof(new_body_size));
-                return;
+                memcpy(payload.data() + 8, &new_body_size, sizeof(new_body_size));
+                return payload;
             }
         }
         std::copy(body_.value().begin(), body_.value().end(), body_itr);
+        return payload;
     }
 };
 } // namespace couchbase::protocol

package/deps/couchbase-transactions-cxx/deps/couchbase-cxx-client/couchbase/protocol/client_response.cxx

@@ -36,9 +36,9 @@ parse_server_duration_us(const io::mcbp_message& msg)
     }
     std::size_t offset = 0;
     while (offset < framing_extras_size) {
-        auto frame_size = static_cast<std::uint8_t>(msg.body[offset] & 0xfU);
-        auto frame_id = static_cast<std::uint8_t>((static_cast<std::uint32_t>(msg.body[offset]) >> 4U) & 0xfU);
-        offset++;
+        auto frame_size = std::to_integer<std::uint8_t>(msg.body[offset] & std::byte{ 0b1111 });
+        auto frame_id = std::to_integer<std::uint8_t>((msg.body[offset] >> 4U) & std::byte{ 0b1111 });
+        ++offset;
         if (frame_id == static_cast<std::uint8_t>(response_frame_info_id::server_duration)) {
             if (frame_size == 2 && framing_extras_size - offset >= frame_size) {
                 std::uint16_t encoded_duration{};
@@ -53,7 +53,7 @@ parse_server_duration_us(const io::mcbp_message& msg)
 }
 
 bool
-parse_enhanced_error(const std::string& str, enhanced_error_info& info)
+parse_enhanced_error(std::string_view str, enhanced_error_info& info)
 {
     if (auto error = utils::json::parse(str); error.is_object()) {
         if (const auto* err_obj = error.find("error"); err_obj != nullptr && err_obj->is_object()) {

package/deps/couchbase-transactions-cxx/deps/couchbase-cxx-client/couchbase/protocol/client_response.hxx

@@ -45,7 +45,7 @@ double
 parse_server_duration_us(const io::mcbp_message& msg);
 
 bool
-parse_enhanced_error(const std::string& str, enhanced_error_info& info);
+parse_enhanced_error(std::string_view str, enhanced_error_info& info);
 
 template<typename Body>
 class client_response
@@ -55,8 +55,8 @@ class client_response
     magic magic_{ magic::client_response };
     client_opcode opcode_{ client_opcode::invalid };
     header_buffer header_{};
-    uint8_t data_type_{ 0 };
-    std::vector<std::uint8_t> data_{};
+    std::uint8_t data_type_{ 0 };
+    std::vector<std::byte> data_{};
     std::uint16_t key_size_{ 0 };
     std::uint8_t framing_extras_size_{ 0 };
     std::uint8_t extras_size_{ 0 };
@@ -93,11 +93,6 @@ class client_response
         return status_;
     }
 
-    [[nodiscard]] std::size_t body_size() const
-    {
-        return body_size_;
-    }
-
     [[nodiscard]] couchbase::cas cas() const
     {
         return couchbase::cas{ cas_ };
@@ -125,22 +120,22 @@ class client_response
 
     void verify_header()
     {
-        Expects(header_[0] == static_cast<std::uint8_t>(magic::alt_client_response) ||
-                header_[0] == static_cast<std::uint8_t>(magic::client_response));
-        Expects(header_[1] == static_cast<std::uint8_t>(Body::opcode));
-        magic_ = magic(header_[0]);
-        opcode_ = client_opcode(header_[1]);
-        data_type_ = header_[5];
+        Expects(header_[0] == static_cast<std::byte>(magic::alt_client_response) ||
+                header_[0] == static_cast<std::byte>(magic::client_response));
+        Expects(header_[1] == static_cast<std::byte>(Body::opcode));
+        magic_ = static_cast<magic>(header_[0]);
+        opcode_ = static_cast<client_opcode>(header_[1]);
+        data_type_ = std::to_integer<std::uint8_t>(header_[5]);
 
         uint16_t status = 0;
         memcpy(&status, header_.data() + 6, sizeof(status));
         status = utils::byte_swap(status);
-        status_ = protocol::status(status);
+        status_ = static_cast<protocol::status>(status);
 
-        extras_size_ = header_[4];
+        extras_size_ = std::to_integer<std::uint8_t>(header_[4]);
         if (magic_ == magic::alt_client_response) {
-            framing_extras_size_ = header_[2];
-            key_size_ = header_[3];
+            framing_extras_size_ = std::to_integer<std::uint8_t>(header_[2]);
+            key_size_ = std::to_integer<std::uint8_t>(header_[3]);
         } else {
             memcpy(&key_size_, header_.data() + 2, sizeof(key_size_));
             key_size_ = utils::byte_swap(key_size_);
@@ -176,7 +171,10 @@ class client_response
         bool parsed = body_.parse(status_, header_, framing_extras_size_, key_size_, extras_size_, data_, info_);
         if (status_ != protocol::status::success && !parsed && has_json_datatype(data_type_)) {
             enhanced_error_info err;
-            if (parse_enhanced_error(std::string(data_.begin() + framing_extras_size_ + extras_size_ + key_size_, data_.end()), err)) {
+            std::vector<uint8_t>::difference_type offset = framing_extras_size_ + extras_size_ + key_size_;
+            std::string_view enhanced_error_text{ reinterpret_cast<const char*>(data_.data()) + offset,
+                                                  data_.size() - static_cast<std::size_t>(offset) };
+            if (parse_enhanced_error(enhanced_error_text, err)) {
                 error_.emplace(err);
             }
         }
@@ -189,9 +187,9 @@ class client_response
         }
         size_t offset = 0;
         while (offset < framing_extras_size_) {
-            std::uint8_t frame_size = data_[offset] & 0xfU;
-            std::uint8_t frame_id = (static_cast<std::uint32_t>(data_[offset]) >> 4U) & 0xfU;
-            offset++;
+            auto frame_size = std::to_integer<std::uint8_t>(data_[offset] & std::byte{ 0b1111 });
+            auto frame_id = std::to_integer<std::uint8_t>((data_[offset] >> 4U) & std::byte{ 0b1111 });
+            ++offset;
             if (frame_id == static_cast<std::uint8_t>(response_frame_info_id::server_duration) && frame_size == 2 &&
                 framing_extras_size_ - offset >= frame_size) {
                 std::uint16_t encoded_duration{};
@@ -203,7 +201,7 @@ class client_response
         }
     }
 
-    [[nodiscard]] std::vector<std::uint8_t>& data()
+    [[nodiscard]] std::vector<std::byte>& data()
     {
         return data_;
     }

package/deps/couchbase-transactions-cxx/deps/couchbase-cxx-client/couchbase/protocol/cmd_append.cxx

@@ -17,7 +17,7 @@
 
 #include <couchbase/protocol/cmd_append.hxx>
 
-#include <couchbase/protocol/frame_info_id.hxx>
+#include <couchbase/protocol/frame_info_utils.hxx>
 #include <couchbase/utils/byteswap.hxx>
 #include <couchbase/utils/unsigned_leb128.hxx>
 
@@ -32,10 +32,10 @@ protocol::append_response_body::parse(protocol::status status,
                                       std::uint8_t framing_extras_size,
                                       std::uint16_t /* key_size */,
                                       std::uint8_t extras_size,
-                                      const std::vector<uint8_t>& body,
+                                      const std::vector<std::byte>& body,
                                       const cmd_info& /* info */)
 {
-    Expects(header[1] == static_cast<uint8_t>(opcode));
+    Expects(header[1] == static_cast<std::byte>(opcode));
     if (status == protocol::status::success) {
         std::vector<uint8_t>::difference_type offset = framing_extras_size;
         if (extras_size == 16) {
@@ -50,14 +50,11 @@ protocol::append_response_body::parse(protocol::status status,
     }
     return false;
 }
+
 void
 protocol::append_request_body::id(const document_id& id)
 {
-    key_ = id.key();
-    if (id.is_collection_resolved()) {
-        utils::unsigned_leb128<uint32_t> encoded(id.collection_uid());
-        key_.insert(0, encoded.get());
-    }
+    key_ = make_protocol_key(id);
 }
 
 void
@@ -66,17 +63,7 @@ protocol::append_request_body::durability(protocol::durability_level level, std:
     if (level == protocol::durability_level::none) {
         return;
     }
-    auto frame_id = static_cast<uint8_t>(protocol::request_frame_info_id::durability_requirement);
-    if (timeout) {
-        framing_extras_.resize(4);
-        framing_extras_[0] = static_cast<std::uint8_t>((static_cast<std::uint32_t>(frame_id) << 4U) | 3U);
-        framing_extras_[1] = static_cast<std::uint8_t>(level);
-        uint16_t val = utils::byte_swap(*timeout);
-        memcpy(framing_extras_.data() + 2, &val, sizeof(val));
-    } else {
-        framing_extras_.resize(2);
-        framing_extras_[0] = static_cast<std::uint8_t>(static_cast<std::uint32_t>(frame_id) << 4U | 1U);
-        framing_extras_[1] = static_cast<std::uint8_t>(level);
-    }
+
+    add_durability_frame_info(framing_extras_, level, timeout);
 }
 } // namespace couchbase::protocol

package/deps/couchbase-transactions-cxx/deps/couchbase-cxx-client/couchbase/protocol/cmd_append.hxx

@@ -50,7 +50,7 @@ class append_response_body
                std::uint8_t framing_extras_size,
                std::uint16_t key_size,
                std::uint8_t extras_size,
-               const std::vector<uint8_t>& body,
+               const std::vector<std::byte>& body,
                const cmd_info& info);
 };
 
@@ -61,10 +61,10 @@ class append_request_body
     static const inline client_opcode opcode = client_opcode::append;
 
   private:
-    std::string key_{};
-    std::vector<std::uint8_t> extras_{};
-    std::vector<std::uint8_t> content_{};
-    std::vector<std::uint8_t> framing_extras_{};
+    std::vector<std::byte> key_{};
+    std::vector<std::byte> extras_{};
+    std::vector<std::byte> content_{};
+    std::vector<std::byte> framing_extras_{};
 
     static inline std::vector<std::uint8_t> empty;
 
@@ -73,27 +73,27 @@ class append_request_body
 
     void durability(protocol::durability_level level, std::optional<std::uint16_t> timeout);
 
-    void content(const std::string_view& content)
+    void content(const std::vector<std::byte>& content)
     {
         content_ = { content.begin(), content.end() };
     }
 
-    [[nodiscard]] const std::string& key() const
+    [[nodiscard]] const auto& key() const
     {
         return key_;
     }
 
-    [[nodiscard]] const std::vector<std::uint8_t>& framing_extras() const
+    [[nodiscard]] const auto& framing_extras() const
     {
         return framing_extras_;
     }
 
-    [[nodiscard]] const std::vector<std::uint8_t>& extras() const
+    [[nodiscard]] const auto& extras() const
     {
         return empty_buffer;
     }
 
-    [[nodiscard]] const std::vector<std::uint8_t>& value() const
+    [[nodiscard]] const auto& value() const
     {
         return content_;
     }

package/deps/couchbase-transactions-cxx/deps/couchbase-cxx-client/couchbase/protocol/cmd_cluster_map_change_notification.cxx

@@ -27,12 +27,12 @@
 namespace couchbase::protocol
 {
 bool
-cluster_map_change_notification_request_body::parse(const header_buffer& header, const std::vector<uint8_t>& body, const cmd_info& info)
+cluster_map_change_notification_request_body::parse(const header_buffer& header, const std::vector<std::byte>& body, const cmd_info& info)
 {
-    Expects(header[1] == static_cast<uint8_t>(opcode));
-    using offset_type = std::vector<uint8_t>::difference_type;
+    Expects(header[1] == static_cast<std::byte>(opcode));
+    using offset_type = std::vector<std::byte>::difference_type;
 
-    uint8_t ext_size = header[4];
+    auto ext_size = std::to_integer<std::uint8_t>(header[4]);
     offset_type offset = ext_size;
     if (ext_size == 4) {
         memcpy(&protocol_revision_, body.data(), sizeof(protocol_revision_));
@@ -41,10 +41,12 @@ cluster_map_change_notification_request_body::parse(const header_buffer& header,
     uint16_t key_size = 0;
     memcpy(&key_size, header.data() + 2, sizeof(key_size));
     key_size = utils::byte_swap(key_size);
-    bucket_.assign(body.begin() + offset, body.begin() + offset + key_size);
+    const auto* data_ptr = reinterpret_cast<const char*>(body.data());
+    bucket_.assign(data_ptr + offset, data_ptr + offset + key_size);
     offset += key_size;
     if (body.size() > static_cast<std::size_t>(offset)) {
-        config_ = parse_config(std::string(body.begin() + offset, body.end()), info.endpoint_address, info.endpoint_port);
+        std::string_view config_text{ data_ptr + offset, body.size() - static_cast<std::size_t>(offset) };
+        config_ = parse_config(config_text, info.endpoint_address, info.endpoint_port);
     }
     return true;
 }

package/deps/couchbase-transactions-cxx/deps/couchbase-cxx-client/couchbase/protocol/cmd_cluster_map_change_notification.hxx

@@ -51,7 +51,7 @@ class cluster_map_change_notification_request_body
         return config_;
     }
 
-    bool parse(const header_buffer& header, const std::vector<uint8_t>& body, const cmd_info& info);
+    bool parse(const header_buffer& header, const std::vector<std::byte>& body, const cmd_info& info);
 };
 
 } // namespace couchbase::protocol