couchbase 4.1.1 → 4.1.2

package/deps/couchbase-transactions-cxx/deps/couchbase-cxx-client/bin/build-tests.rb

@@ -48,6 +48,7 @@ CB_CC = ENV.fetch("CB_CC", which(CB_DEFAULT_CC))
 CB_CXX = ENV.fetch("CB_CXX", which(CB_DEFAULT_CXX))
 CB_NUMBER_OF_JOBS = ENV.fetch("CB_NUMBER_OF_JOBS", "1").to_i
 CB_CMAKE_BUILD_TYPE = ENV.fetch("CB_CMAKE_BUILD_TYPE", "Debug")
+CB_CACHE_OPTION = ENV.fetch("CB_CACHE_OPTION", "ccache")
 
 puts "RUBY_PLATFORM=#{RUBY_PLATFORM}"
 puts "CB_CMAKE=#{CB_CMAKE}"
@@ -58,6 +59,7 @@ if RUBY_PLATFORM !~ /mswin|mingw/
   puts "CB_CC=#{CB_CC}"
   puts "CB_CXX=#{CB_CXX}"
 end
+puts "CB_CACHE_OPTION=#{CB_CACHE_OPTION}"
 
 CB_CMAKE_EXTRAS = []
 case CB_SANITIZER
@@ -91,6 +93,7 @@ Dir.chdir(BUILD_DIR) do
   run(CB_CMAKE,
       "-DCMAKE_BUILD_TYPE=#{CB_CMAKE_BUILD_TYPE}",
       "-DCOUCHBASE_CXX_CLIENT_BUILD_TESTS=ON",
+      "-DCACHE_OPTION=#{CB_CACHE_OPTION}",
       *CB_CMAKE_EXTRAS,
       "-B", BUILD_DIR,
       "-S", PROJECT_ROOT)

package/deps/couchbase-transactions-cxx/deps/couchbase-cxx-client/bin/init-cluster

@@ -30,7 +30,7 @@ options = {
   username: ENV.fetch("CB_USERNAME", "Administrator"),
   password: ENV.fetch("CB_PASSWORD", "password"),
   bucket: ENV.fetch("CB_BUCKET", "default"),
-  server_quota: ENV.fetch("CB_SERVER_QUOTA", 1024).to_i,
+  server_quota: ENV.fetch("CB_SERVER_QUOTA", 2048).to_i,
   index_quota: ENV.fetch("CB_INDEX_QUOTA", 256).to_i,
   bucket_quota: ENV.fetch("CB_BUCKET_QUOTA", 256).to_i,
   enable_developer_preview: ENV.fetch("CB_DEVELOPER_PREVIEW", false).to_b,

package/deps/couchbase-transactions-cxx/deps/couchbase-cxx-client/bin/run-tests

@@ -30,4 +30,4 @@ fi
 
 cd "${BUILD_DIR}"
 
-${CB_CTEST} --output-on-failure --label-regex 'integration|unit'
+${CB_CTEST} --output-on-failure --label-regex 'integration|unit' --output-junit results.xml

package/deps/couchbase-transactions-cxx/deps/couchbase-cxx-client/cmake/CompilerWarnings.cmake

@@ -7,6 +7,7 @@ function(set_project_warnings project_name)
 
   set(MSVC_WARNINGS
       /W4 # Baseline reasonable warnings
+      /wd4189 # 'identifier': local variable is initialized but not referenced
       /wd4242 # 'identifier': conversion from 'type1' to 'type1', possible loss of data
       /wd4244 # 'identifier': conversion from 'type1' to 'type1', possible loss of data
       /w14254 # 'operator': conversion from 'type1:field_bits' to 'type2:field_bits', possible loss of data

package/deps/couchbase-transactions-cxx/deps/couchbase-cxx-client/cmake/OpenSSL.cmake

@@ -1,4 +1,5 @@
 option(COUCHBASE_CXX_CLIENT_POST_LINKED_OPENSSL "Rely on application to link OpenSSL library" FALSE)
+option(COUCHBASE_CXX_CLIENT_USE_HOMEBREW_TO_DETECT_OPENSSL "Use homebrew to determine OpenSSL root directory" TRUE)
 
 if(COUCHBASE_CXX_CLIENT_POST_LINKED_OPENSSL)
   message(
@@ -9,6 +10,13 @@ else()
   if(COUCHBASE_CXX_CLIENT_STATIC_OPENSSL)
     set(OPENSSL_USE_STATIC_LIBS ON)
   endif()
+  if(APPLE AND COUCHBASE_CXX_CLIENT_USE_HOMEBREW_TO_DETECT_OPENSSL)
+    execute_process(
+      COMMAND brew --prefix openssl@1.1
+      OUTPUT_VARIABLE OPENSSL_ROOT_DIR
+      OUTPUT_STRIP_TRAILING_WHITESPACE)
+    message(STATUS "Found OpenSSL prefix using homebrew: ${OPENSSL_ROOT_DIR}")
+  endif()
   include(FindOpenSSL)
   if(OPENSSL_LIBRARIES AND OPENSSL_INCLUDE_DIR)
     message(STATUS "OPENSSL_VERSION: ${OPENSSL_VERSION}")

package/deps/couchbase-transactions-cxx/deps/couchbase-cxx-client/cmake/StandardProjectSettings.cmake

@@ -39,7 +39,7 @@ else()
   message(STATUS "No colored compiler diagnostic set for '${CMAKE_CXX_COMPILER_ID}' compiler.")
 endif()
 
-if(WIN32)
+if(MSVC)
   add_definitions(/bigobj)
 endif()
 

package/deps/couchbase-transactions-cxx/deps/couchbase-cxx-client/couchbase/cluster.cxx

@@ -28,7 +28,7 @@ class ping_collector : public std::enable_shared_from_this<ping_collector>
 
   public:
     ping_collector(std::string report_id, utils::movable_function<void(diag::ping_result)>&& handler)
-      : res_{ std::move(report_id), couchbase::meta::sdk_id() }
+      : res_{ std::move(report_id), meta::sdk_id() }
       , handler_(std::move(handler))
     {
     }
@@ -45,7 +45,7 @@ class ping_collector : public std::enable_shared_from_this<ping_collector>
 
     auto build_reporter()
     {
-        expected_++;
+        ++expected_;
         return [self = this->shared_from_this()](diag::endpoint_ping_info&& info) {
             std::scoped_lock lock(self->mutex_);
             self->res_.services[info.type].emplace_back(std::move(info));
@@ -74,27 +74,40 @@ cluster::do_ping(std::optional<std::string> report_id,
         report_id = std::make_optional(uuid::to_string(uuid::random()));
     }
     if (stopped_) {
-        return handler({ report_id.value(), couchbase::meta::sdk_id() });
+        return handler({ report_id.value(), meta::sdk_id() });
     }
     if (services.empty()) {
-        services = { service_type::key_value, service_type::view, service_type::query, service_type::search, service_type::analytics };
+        services = {
+            service_type::key_value, service_type::view,       service_type::query,    service_type::search,
+            service_type::analytics, service_type::management, service_type::eventing,
+        };
     }
-    asio::post(asio::bind_executor(ctx_, [this, report_id, bucket_name, services, handler = std::move(handler)]() mutable {
-        auto collector = std::make_shared<ping_collector>(report_id.value(), std::move(handler));
-        if (bucket_name) {
-            if (services.find(service_type::key_value) != services.end()) {
-                for_each_bucket([&collector](auto& bucket) { bucket->ping(collector); });
-            }
-        } else {
-            if (services.find(service_type::key_value) != services.end()) {
-                if (session_) {
-                    session_->ping(collector->build_reporter());
-                }
-                for_each_bucket([&collector](auto& bucket) { bucket->ping(collector); });
-            }
-            session_manager_->ping(services, collector, origin_.credentials());
-        }
-    }));
+    asio::post(
+      asio::bind_executor(ctx_, [cluster = shared_from_this(), report_id, bucket_name, services, handler = std::move(handler)]() mutable {
+          auto collector = std::make_shared<ping_collector>(report_id.value(), std::move(handler));
+          if (bucket_name) {
+              if (services.find(service_type::key_value) != services.end()) {
+                  if (auto bucket = cluster->find_bucket_by_name(bucket_name.value()); bucket) {
+                      return bucket->ping(collector);
+                  }
+                  cluster->open_bucket(bucket_name.value(), [collector, cluster, bucket_name](std::error_code ec) {
+                      if (!ec) {
+                          if (auto bucket = cluster->find_bucket_by_name(bucket_name.value()); bucket) {
+                              return bucket->ping(collector);
+                          }
+                      }
+                  });
+              }
+          } else {
+              if (services.find(service_type::key_value) != services.end()) {
+                  if (cluster->session_) {
+                      cluster->session_->ping(collector->build_reporter());
+                  }
+                  cluster->for_each_bucket([&collector](auto& bucket) { bucket->ping(collector); });
+              }
+              cluster->session_manager_->ping(services, collector, cluster->origin_.credentials());
+          }
+      }));
 }
 
 std::shared_ptr<bucket>

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

@@ -49,6 +49,14 @@ class cluster : public std::enable_shared_from_this<cluster>
         return std::shared_ptr<cluster>(new cluster(ctx));
     }
 
+    [[nodiscard]] std::pair<std::error_code, couchbase::origin> origin() const
+    {
+        if (stopped_) {
+            return { error::network_errc::cluster_closed, {} };
+        }
+        return { {}, origin_ };
+    }
+
     template<typename Handler>
     void open(const couchbase::origin& origin, Handler&& handler)
     {
@@ -289,21 +297,32 @@ class cluster : public std::enable_shared_from_this<cluster>
     {
         // Warn users if they attempt to use Capella without TLS being enabled.
         {
-            bool is_capella = false;
+            bool has_capella_host = false;
+            bool has_non_capella_host = false;
             static std::string suffix = "cloud.couchbase.com";
-            auto nodes_list = origin_.get_nodes();
-            for (auto& node : nodes_list) {
+            for (const auto& node : origin_.get_hostnames()) {
                 if (auto pos = node.find(suffix); pos != std::string::npos && pos + suffix.size() == node.size()) {
-                    is_capella = true;
-                    break;
+                    has_capella_host = true;
+                } else {
+                    has_non_capella_host = true;
                 }
             }
 
-            if (is_capella && !origin_.options().enable_tls) {
+            if (has_capella_host && !origin_.options().enable_tls) {
                 LOG_WARNING("[{}]: TLS is required when connecting to Couchbase Capella. Please enable TLS by prefixing "
                             "the connection string with \"couchbases://\" (note the final 's').",
                             id_);
             }
+
+            if (origin_.options().enable_tls                   /* TLS is enabled */
+                && origin_.options().trust_certificate.empty() /* No CA certificate (or other SDK-specific trust source) is specified */
+                && origin_.options().tls_verify != tls_verify_mode::none /* The user did not disable all TLS verification */
+                && has_non_capella_host /* The connection string has a hostname that does NOT end in ".cloud.couchbase.com" */) {
+                LOG_ERROR("[{}] When TLS is enabled, the cluster options must specify certificate(s) to trust. (Unless connecting to "
+                          "cloud.couchbase.com.)",
+                          id_);
+                return handler(error::common_errc::invalid_argument);
+            }
         }
 
         if (origin_.options().enable_tls) {

package/deps/couchbase-transactions-cxx/deps/couchbase-cxx-client/couchbase/crypto/cbcrypto.cc

@@ -50,7 +50,7 @@ hash(std::string_view key, std::string_view data, LPCWSTR algorithm, int flags)
     DWORD cbHashObject = 0;
 
     // calculate the size of the buffer to hold the hash object
-    status = BCryptGetProperty(hAlg, BCRYPT_OBJECT_LENGTH, (PBYTE)&cbHashObject, sizeof(DWORD), &pcbResult, 0);
+    status = BCryptGetProperty(hAlg, BCRYPT_OBJECT_LENGTH, reinterpret_cast<PBYTE>(&cbHashObject), sizeof(DWORD), &pcbResult, 0);
     if (status < 0) {
         BCryptCloseAlgorithmProvider(hAlg, 0);
         throw std::runtime_error("digest: BCryptGetProperty return: " + std::to_string(status));
@@ -58,14 +58,14 @@ hash(std::string_view key, std::string_view data, LPCWSTR algorithm, int flags)
 
     // calculate the length of the hash
     DWORD cbHash = 0;
-    status = BCryptGetProperty(hAlg, BCRYPT_HASH_LENGTH, (PBYTE)&cbHash, sizeof(DWORD), &pcbResult, 0);
+    status = BCryptGetProperty(hAlg, BCRYPT_HASH_LENGTH, reinterpret_cast<PBYTE>(&cbHash), sizeof(DWORD), &pcbResult, 0);
     if (status < 0) {
         BCryptCloseAlgorithmProvider(hAlg, 0);
         throw std::runtime_error("digest: BCryptGetProperty return: " + std::to_string(status));
     }
 
     // allocate the hash object on the heap
-    uniqueHeapPtr pbHashObject((PBYTE)HeapAlloc(GetProcessHeap(), 0, cbHashObject));
+    uniqueHeapPtr pbHashObject(static_cast<PBYTE>(HeapAlloc(GetProcessHeap(), 0, cbHashObject)));
     if (!pbHashObject) {
         BCryptCloseAlgorithmProvider(hAlg, 0);
         throw std::bad_alloc();
@@ -76,13 +76,13 @@ hash(std::string_view key, std::string_view data, LPCWSTR algorithm, int flags)
 
     // create the hash
     BCRYPT_HASH_HANDLE hHash;
-    status = BCryptCreateHash(hAlg, &hHash, pbHashObject.get(), cbHashObject, (PUCHAR)key.data(), ULONG(key.size()), 0);
+    status = BCryptCreateHash(hAlg, &hHash, pbHashObject.get(), cbHashObject, (PUCHAR)key.data(), static_cast<ULONG>(key.size()), 0);
     if (status < 0) {
         BCryptCloseAlgorithmProvider(hAlg, 0);
         throw std::runtime_error("digest: BCryptCreateHash return: " + std::to_string(status));
     }
 
-    status = BCryptHashData(hHash, (PBYTE)data.data(), ULONG(data.size()), 0);
+    status = BCryptHashData(hHash, (PBYTE)data.data(), static_cast<ULONG>(data.size()), 0);
     if (status < 0) {
         BCryptCloseAlgorithmProvider(hAlg, 0);
         BCryptDestroyHash(hHash);

package/deps/couchbase-transactions-cxx/deps/couchbase-cxx-client/couchbase/document_id.cxx

@@ -17,6 +17,9 @@
 
 #include <couchbase/document_id.hxx>
 
+#include <couchbase/utils/binary.hxx>
+#include <couchbase/utils/unsigned_leb128.hxx>
+
 #include <fmt/core.h>
 
 #include <algorithm>
@@ -25,9 +28,9 @@
 namespace couchbase
 {
 document_id::document_id()
-  : scope_("_default")
-  , collection_("_default")
-  , collection_path_("_default._default")
+  : scope_{ "_default" }
+  , collection_{ "_default" }
+  , collection_path_{ "_default._default" }
 {
 }
 
@@ -86,4 +89,18 @@ document_id::has_default_collection() const
 {
     return !use_collections_ || collection_path_ == "_default._default";
 }
+
+std::vector<std::byte>
+make_protocol_key(const document_id& id)
+{
+    std::vector<std::byte> key{};
+    if (id.is_collection_resolved()) {
+        utils::unsigned_leb128<std::uint32_t> encoded(id.collection_uid());
+        key.reserve(encoded.size());
+        key.insert(key.end(), encoded.begin(), encoded.end());
+    }
+    key.reserve(key.size() + id.key().size());
+    couchbase::utils::to_binary(id.key(), std::back_insert_iterator(key));
+    return key;
+}
 } // namespace couchbase

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

@@ -20,6 +20,7 @@
 #include <cstdint>
 #include <optional>
 #include <string>
+#include <vector>
 
 namespace couchbase
 {
@@ -99,4 +100,8 @@ struct document_id {
     bool use_collections_{ true };
     bool use_any_session_{ false };
 };
+
+[[nodiscard]] std::vector<std::byte>
+make_protocol_key(const document_id& id);
+
 } // namespace couchbase

package/deps/couchbase-transactions-cxx/deps/couchbase-cxx-client/couchbase/io/dns_client.hxx

@@ -154,7 +154,7 @@ class dns_client
                             return handler({ ec2 });
                         }
                         asio::async_read(self->tcp_,
-                                         asio::buffer(&self->recv_buf_size_, sizeof(self->recv_buf_size_)),
+                                         asio::buffer(&self->recv_buf_size_, sizeof(std::uint16_t)),
                                          [self, handler = std::forward<Handler>(handler)](std::error_code ec3,
                                                                                           std::size_t /* bytes_transferred */) mutable {
                                              if (ec3) {

package/deps/couchbase-transactions-cxx/deps/couchbase-cxx-client/couchbase/io/http_parser.cxx

@@ -125,7 +125,7 @@ http_parser::error_message() const
 
     switch (state_->parser_.http_errno) {
         HTTP_ERRNO_MAP(HTTP_ERRNO_GEN)
-    };
+    }
 #undef HTTP_ERRNO_GEN
     return "unknown error: " + std::to_string(state_->parser_.http_errno);
 }

package/deps/couchbase-transactions-cxx/deps/couchbase-cxx-client/couchbase/io/http_session.hxx

@@ -397,7 +397,11 @@ class http_session : public std::enable_shared_from_this<http_session>
                         it->endpoint().port(),
                         ec.message(),
                         (ec == asio::error::connection_refused) ? ", check server ports and cluster encryption setting" : "");
-            do_connect(++it);
+            if (stream_->is_open()) {
+                stream_->close(std::bind(&http_session::do_connect, shared_from_this(), ++it));
+            } else {
+                do_connect(++it);
+            }
         } else {
             state_ = diag::endpoint_state::connected;
             connected_ = true;
@@ -406,7 +410,6 @@ class http_session : public std::enable_shared_from_this<http_session>
                 std::scoped_lock lock(info_mutex_);
                 info_ = http_session_info(client_id_, id_, stream_->local_endpoint(), it->endpoint());
             }
-            deadline_timer_.expires_at(asio::steady_timer::time_point::max());
             deadline_timer_.cancel();
             flush();
         }
@@ -419,7 +422,8 @@ class http_session : public std::enable_shared_from_this<http_session>
         }
         if (deadline_timer_.expiry() <= asio::steady_timer::clock_type::now()) {
             stream_->close([](std::error_code) {});
-            deadline_timer_.expires_at(asio::steady_timer::time_point::max());
+            deadline_timer_.cancel();
+            return;
         }
         deadline_timer_.async_wait(std::bind(&http_session::check_deadline, shared_from_this(), std::placeholders::_1));
     }

package/deps/couchbase-transactions-cxx/deps/couchbase-cxx-client/couchbase/io/http_session_manager.hxx

@@ -99,7 +99,10 @@ class http_session_manager : public std::enable_shared_from_this<http_session_ma
     template<typename Collector>
     void ping(std::set<service_type> services, std::shared_ptr<Collector> collector, const couchbase::cluster_credentials& credentials)
     {
-        std::array<service_type, 4> known_types{ service_type::query, service_type::analytics, service_type::search, service_type::view };
+        std::array known_types{
+            service_type::query, service_type::analytics, service_type::search,
+            service_type::view,  service_type::eventing,  service_type::management,
+        };
         std::vector<topology::configuration::node> nodes{};
         {
             std::scoped_lock lock(config_mutex_);
@@ -229,6 +232,7 @@ class http_session_manager : public std::enable_shared_from_this<http_session_ma
 
     void close()
     {
+        std::scoped_lock lock(sessions_mutex_);
         for (auto& [type, sessions] : idle_sessions_) {
             for (auto& s : sessions) {
                 if (s) {

package/deps/couchbase-transactions-cxx/deps/couchbase-cxx-client/couchbase/io/mcbp_command.hxx

@@ -239,12 +239,12 @@ struct mcbp_command : public std::enable_shared_from_this<mcbp_command<Manager,
               protocol::status status = protocol::status::invalid;
               std::optional<error_map::error_info> error_code{};
               if (protocol::is_valid_status(msg.header.status())) {
-                  status = protocol::status(msg.header.status());
+                  status = static_cast<protocol::status>(msg.header.status());
               } else {
                   error_code = self->session_->decode_error_code(msg.header.status());
               }
               if (status == protocol::status::not_my_vbucket) {
-                  self->session_->handle_not_my_vbucket(std::move(msg));
+                  self->session_->handle_not_my_vbucket(msg);
                   return io::retry_orchestrator::maybe_retry(self->manager_, self, io::retry_reason::kv_not_my_vbucket, ec);
               }
               if (status == protocol::status::unknown_collection) {

package/deps/couchbase-transactions-cxx/deps/couchbase-cxx-client/couchbase/io/mcbp_message.hxx

@@ -26,7 +26,7 @@ namespace couchbase
 namespace protocol
 {
 static const std::size_t header_size = 24;
-using header_buffer = std::array<std::uint8_t, header_size>;
+using header_buffer = std::array<std::byte, header_size>;
 } // namespace protocol
 
 namespace io
@@ -47,7 +47,7 @@ struct binary_header {
 
 struct mcbp_message {
     binary_header header;
-    std::vector<std::uint8_t> body;
+    std::vector<std::byte> body;
 
     [[nodiscard]] protocol::header_buffer header_data() const;
 };

package/deps/couchbase-transactions-cxx/deps/couchbase-cxx-client/couchbase/io/mcbp_parser.cxx

@@ -22,11 +22,12 @@
 #include <couchbase/protocol/magic.hxx>
 #include <couchbase/utils/byteswap.hxx>
 
-#include <cstring>
-#include <gsl/assert>
 #include <snappy.h>
 #include <spdlog/fmt/bin_to_hex.h>
 
+#include <algorithm>
+#include <cstring>
+
 namespace couchbase::io
 {
 mcbp_parser::result
@@ -44,22 +45,23 @@ mcbp_parser::next(mcbp_message& msg)
     msg.body.clear();
     msg.body.reserve(body_size);
     std::uint32_t key_size = utils::byte_swap(msg.header.keylen);
-    std::uint32_t prefix_size = std::uint32_t(msg.header.extlen) + key_size;
+    std::uint32_t prefix_size = static_cast<std::uint32_t>(msg.header.extlen) + key_size;
     if (msg.header.magic == static_cast<uint8_t>(protocol::magic::alt_client_response)) {
         std::uint8_t framing_extras_size = msg.header.keylen & 0xfU;
         key_size = (msg.header.keylen & 0xf0U) >> 8U;
-        prefix_size = std::uint32_t(framing_extras_size) + std::uint32_t(msg.header.extlen) + key_size;
+        prefix_size = static_cast<std::uint32_t>(framing_extras_size) + static_cast<std::uint32_t>(msg.header.extlen) + key_size;
     }
     std::copy(buf.begin() + header_size, buf.begin() + header_size + prefix_size, std::back_insert_iterator(msg.body));
 
-    bool is_compressed = (msg.header.datatype & static_cast<uint8_t>(protocol::datatype::snappy)) != 0;
+    bool is_compressed = (msg.header.datatype & static_cast<std::uint8_t>(protocol::datatype::snappy)) != 0;
     bool use_raw_value = true;
     if (is_compressed) {
         std::string uncompressed;
         size_t offset = header_size + prefix_size;
-        bool success = snappy::Uncompress(reinterpret_cast<const char*>(buf.data() + offset), body_size - prefix_size, &uncompressed);
-        if (success) {
-            std::copy(uncompressed.begin(), uncompressed.end(), std::back_insert_iterator(msg.body));
+        if (snappy::Uncompress(reinterpret_cast<const char*>(buf.data() + offset), body_size - prefix_size, &uncompressed)) {
+            std::transform(uncompressed.begin(), uncompressed.end(), std::back_insert_iterator(msg.body), [](auto ch) {
+                return static_cast<std::byte>(ch);
+            });
             use_raw_value = false;
             // patch header with new body size
             msg.header.bodylen = utils::byte_swap(static_cast<std::uint32_t>(prefix_size + uncompressed.size()));
@@ -69,7 +71,7 @@ mcbp_parser::next(mcbp_message& msg)
         std::copy(buf.begin() + header_size + prefix_size, buf.begin() + header_size + body_size, std::back_insert_iterator(msg.body));
     }
     buf.erase(buf.begin(), buf.begin() + header_size + body_size);
-    if (!buf.empty() && !protocol::is_valid_magic(buf[0])) {
+    if (!buf.empty() && !protocol::is_valid_magic(std::to_integer<std::uint8_t>(buf[0]))) {
         LOG_WARNING("parsed frame for magic={:x}, opcode={:x}, opaque={}, body_len={}. Invalid magic of the next frame: {:x}, {} "
                     "bytes to parse{}",
                     msg.header.magic,

package/deps/couchbase-transactions-cxx/deps/couchbase-cxx-client/couchbase/io/mcbp_parser.hxx

@@ -40,6 +40,6 @@ struct mcbp_parser {
 
     result next(mcbp_message& msg);
 
-    std::vector<std::uint8_t> buf;
+    std::vector<std::byte> buf;
 };
 } // namespace couchbase::io