couchbase 4.1.1 → 4.1.2

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

@@ -138,11 +138,12 @@ class mcbp_session : public std::enable_shared_from_this<mcbp_session>
                 hello_req.body().enable_compression();
             }
             hello_req.opaque(session_->next_opaque());
-            hello_req.body().user_agent(
-              meta::user_agent_for_mcbp(session_->client_id_, session_->id_, session_->origin_.options().user_agent_extra, 250));
+            auto user_agent =
+              meta::user_agent_for_mcbp(session_->client_id_, session_->id_, session_->origin_.options().user_agent_extra, 250);
+            hello_req.body().user_agent(user_agent);
             LOG_DEBUG("{} user_agent={}, requested_features=[{}]",
                       session_->log_prefix_,
-                      hello_req.body().user_agent(),
+                      user_agent,
                       utils::join_strings_fmt("{}", hello_req.body().features(), ", "));
             session_->write(hello_req.data());
 
@@ -300,7 +301,7 @@ class mcbp_session : public std::enable_shared_from_this<mcbp_session>
                                             session_->log_prefix_,
                                             resp.error_message(),
                                             resp.opaque(),
-                                            spdlog::to_hex(msg.header_data()));
+                                            spdlog::to_hex(resp.header()));
                                 return complete(error::network_errc::protocol_error);
                             }
                         } break;
@@ -327,7 +328,7 @@ class mcbp_session : public std::enable_shared_from_this<mcbp_session>
                                             session_->log_prefix_,
                                             resp.error_message(),
                                             resp.opaque(),
-                                            spdlog::to_hex(msg.header_data()));
+                                            spdlog::to_hex(resp.header()));
                                 return complete(error::common_errc::bucket_not_found);
                             }
                         } break;
@@ -357,7 +358,7 @@ class mcbp_session : public std::enable_shared_from_this<mcbp_session>
                                             session_->log_prefix_,
                                             resp.error_message(),
                                             resp.opaque(),
-                                            spdlog::to_hex(msg.header_data()));
+                                            spdlog::to_hex(resp.header()));
                                 return complete(error::network_errc::protocol_error);
                             }
                         } break;
@@ -405,7 +406,9 @@ class mcbp_session : public std::enable_shared_from_this<mcbp_session>
         }
     };
 
-    class normal_handler : public message_handler
+    class normal_handler
+      : public message_handler
+      , public std::enable_shared_from_this<normal_handler>
     {
       private:
         std::shared_ptr<mcbp_session> session_;
@@ -413,11 +416,18 @@ class mcbp_session : public std::enable_shared_from_this<mcbp_session>
         std::atomic_bool stopped_{ false };
 
       public:
-        ~normal_handler() override = default;
+        ~normal_handler() override
+        {
+            stop();
+        }
 
         explicit normal_handler(std::shared_ptr<mcbp_session> session)
           : session_(session)
           , heartbeat_timer_(session_->ctx_)
+        {
+        }
+
+        void start()
         {
             if (session_->supports_gcccp_) {
                 fetch_config({});
@@ -559,11 +569,11 @@ class mcbp_session : public std::enable_shared_from_this<mcbp_session>
             req.opaque(session_->next_opaque());
             session_->write_and_flush(req.data());
             heartbeat_timer_.expires_after(std::chrono::milliseconds(2500));
-            heartbeat_timer_.async_wait([this](std::error_code e) {
+            heartbeat_timer_.async_wait([self = shared_from_this()](std::error_code e) {
                 if (e == asio::error::operation_aborted) {
                     return;
                 }
-                fetch_config(e);
+                self->fetch_config(e);
             });
         }
     };
@@ -657,7 +667,7 @@ class mcbp_session : public std::enable_shared_from_this<mcbp_session>
         protocol::client_request<protocol::mcbp_noop_request_body> req;
         req.opaque(next_opaque());
         write_and_subscribe(req.opaque(),
-                            req.data(false),
+                            std::move(req.data(false)),
                             [start = std::chrono::steady_clock::now(), self = shared_from_this(), handler](
                               std::error_code ec, retry_reason reason, io::mcbp_message&& /* msg */) {
                                 diag::ping_state state = diag::ping_state::ok;
@@ -782,6 +792,7 @@ class mcbp_session : public std::enable_shared_from_this<mcbp_session>
         }
         if (handler_) {
             handler_->stop();
+            handler_ = nullptr;
         }
         {
             std::scoped_lock lock(command_handlers_mutex_);
@@ -802,7 +813,7 @@ class mcbp_session : public std::enable_shared_from_this<mcbp_session>
         state_ = diag::endpoint_state::disconnected;
     }
 
-    void write(const std::vector<uint8_t>& buf)
+    void write(std::vector<std::byte>&& buf)
     {
         if (stopped_) {
             return;
@@ -811,7 +822,7 @@ class mcbp_session : public std::enable_shared_from_this<mcbp_session>
         std::memcpy(&opaque, buf.data() + 12, sizeof(opaque));
         LOG_TRACE("{} MCBP send, opaque={}, {:n}", log_prefix_, opaque, spdlog::to_hex(buf.begin(), buf.begin() + 24));
         std::scoped_lock lock(output_buffer_mutex_);
-        output_buffer_.push_back(buf);
+        output_buffer_.emplace_back(std::move(buf));
     }
 
     void flush()
@@ -822,17 +833,17 @@ class mcbp_session : public std::enable_shared_from_this<mcbp_session>
         do_write();
     }
 
-    void write_and_flush(const std::vector<uint8_t>& buf)
+    void write_and_flush(std::vector<std::byte>&& buf)
     {
         if (stopped_) {
             return;
         }
-        write(buf);
+        write(std::move(buf));
         flush();
     }
 
-    void write_and_subscribe(uint32_t opaque,
-                             std::vector<std::uint8_t>& data,
+    void write_and_subscribe(std::uint32_t opaque,
+                             std::vector<std::byte>&& data,
                              std::function<void(std::error_code, retry_reason, io::mcbp_message&&)> handler)
     {
         if (stopped_) {
@@ -845,14 +856,14 @@ class mcbp_session : public std::enable_shared_from_this<mcbp_session>
             command_handlers_.try_emplace(opaque, std::move(handler));
         }
         if (bootstrapped_ && stream_->is_open()) {
-            write_and_flush(data);
+            write_and_flush(std::move(data));
         } else {
             LOG_DEBUG("{} the stream is not ready yet, put the message into pending buffer, opaque={}", log_prefix_, opaque);
             std::scoped_lock lock(pending_buffer_mutex_);
             if (bootstrapped_ && stream_->is_open()) {
-                write_and_flush(data);
+                write_and_flush(std::move(data));
             } else {
-                pending_buffer_.push_back(data);
+                pending_buffer_.emplace_back(data);
             }
         }
     }
@@ -980,7 +991,7 @@ class mcbp_session : public std::enable_shared_from_this<mcbp_session>
                 }
             }
         }
-        config_.emplace(config);
+        config_.emplace(std::move(config));
         configured_ = true;
         LOG_DEBUG("{} received new configuration: {}", log_prefix_, config_.value());
         for (const auto& listener : config_listeners_) {
@@ -988,7 +999,7 @@ class mcbp_session : public std::enable_shared_from_this<mcbp_session>
         }
     }
 
-    void handle_not_my_vbucket(io::mcbp_message&& msg)
+    void handle_not_my_vbucket(const io::mcbp_message& msg)
     {
         if (stopped_) {
             return;
@@ -996,7 +1007,7 @@ class mcbp_session : public std::enable_shared_from_this<mcbp_session>
         Expects(msg.header.magic == static_cast<std::uint8_t>(protocol::magic::alt_client_response) ||
                 msg.header.magic == static_cast<std::uint8_t>(protocol::magic::client_response));
         if (protocol::has_json_datatype(msg.header.datatype)) {
-            auto magic = protocol::magic(msg.header.magic);
+            auto magic = static_cast<protocol::magic>(msg.header.magic);
             uint8_t extras_size = msg.header.extlen;
             uint8_t framing_extras_size = 0;
             uint16_t key_size = utils::byte_swap(msg.header.keylen);
@@ -1007,8 +1018,9 @@ class mcbp_session : public std::enable_shared_from_this<mcbp_session>
 
             std::vector<uint8_t>::difference_type offset = framing_extras_size + key_size + extras_size;
             if (utils::byte_swap(msg.header.bodylen) - offset > 0) {
-                auto config =
-                  protocol::parse_config(std::string(msg.body.begin() + offset, msg.body.end()), endpoint_address_, endpoint_.port());
+                std::string_view config_text{ reinterpret_cast<const char*>(msg.body.data()) + offset,
+                                              msg.body.size() - static_cast<std::size_t>(offset) };
+                auto config = protocol::parse_config(config_text, endpoint_address_, endpoint_.port());
                 LOG_DEBUG("{} received not_my_vbucket status for {}, opaque={} with config rev={} in the payload",
                           log_prefix_,
                           protocol::client_opcode(msg.header.opcode),
@@ -1053,12 +1065,16 @@ class mcbp_session : public std::enable_shared_from_this<mcbp_session>
             return stop(retry_reason::node_not_available);
         }
         state_ = diag::endpoint_state::connected;
-        handler_ = std::make_unique<normal_handler>(shared_from_this());
+        {
+            auto handler = std::make_shared<normal_handler>(shared_from_this());
+            handler->start();
+            handler_ = handler;
+        }
         std::scoped_lock lock(pending_buffer_mutex_);
         bootstrapped_ = true;
         if (!pending_buffer_.empty()) {
-            for (const auto& buf : pending_buffer_) {
-                write(buf);
+            for (auto& buf : pending_buffer_) {
+                write(std::move(buf));
             }
             pending_buffer_.clear();
             flush();
@@ -1149,7 +1165,7 @@ class mcbp_session : public std::enable_shared_from_this<mcbp_session>
                                       bootstrap_hostname_,
                                       endpoint_address_,
                                       endpoint_.port());
-            handler_ = std::make_unique<bootstrap_handler>(shared_from_this());
+            handler_ = std::make_shared<bootstrap_handler>(shared_from_this());
             connection_deadline_.expires_at(asio::steady_timer::time_point::max());
             connection_deadline_.cancel();
         }
@@ -1271,7 +1287,7 @@ class mcbp_session : public std::enable_shared_from_this<mcbp_session>
     couchbase::origin origin_;
     std::optional<std::string> bucket_name_;
     mcbp_parser parser_;
-    std::unique_ptr<message_handler> handler_;
+    std::shared_ptr<message_handler> handler_;
     utils::movable_function<void(std::error_code, const topology::configuration&)> bootstrap_handler_{};
     std::mutex command_handlers_mutex_{};
     std::map<uint32_t, utils::movable_function<void(std::error_code, retry_reason, io::mcbp_message&&)>> command_handlers_{};
@@ -1287,10 +1303,10 @@ class mcbp_session : public std::enable_shared_from_this<mcbp_session>
 
     std::atomic<std::uint32_t> opaque_{ 0 };
 
-    std::array<std::uint8_t, 16384> input_buffer_{};
-    std::vector<std::vector<std::uint8_t>> output_buffer_{};
-    std::vector<std::vector<std::uint8_t>> pending_buffer_{};
-    std::vector<std::vector<std::uint8_t>> writing_buffer_{};
+    std::array<std::byte, 16384> input_buffer_{};
+    std::vector<std::vector<std::byte>> output_buffer_{};
+    std::vector<std::vector<std::byte>> pending_buffer_{};
+    std::vector<std::vector<std::byte>> writing_buffer_{};
     std::mutex output_buffer_mutex_{};
     std::mutex pending_buffer_mutex_{};
     std::mutex writing_buffer_mutex_{};

package/deps/couchbase-transactions-cxx/deps/couchbase-cxx-client/couchbase/logger/configuration.hxx

@@ -47,6 +47,11 @@ struct configuration {
      * The default log level to initialize the logger to
      */
     level log_level{ level::info };
+
+    /**
+     * Custom sink to use, if desired
+     */
+    std::shared_ptr<spdlog::sinks::sink> sink{ nullptr };
 };
 
 } // namespace couchbase::logger

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

@@ -68,8 +68,7 @@ translate_level(level level)
 level
 level_from_str(const std::string& str)
 {
-    auto level = spdlog::level::from_str(str);
-    switch (level) {
+    switch (spdlog::level::from_str(str)) {
         case spdlog::level::level_enum::trace:
             return level::trace;
         case spdlog::level::level_enum::debug:
@@ -211,6 +210,10 @@ create_file_logger(const configuration& logger_settings)
             }
             sink->add_sink(stderrsink);
         }
+        if (nullptr != logger_settings.sink) {
+            logger_settings.sink->set_pattern(log_pattern);
+            sink->add_sink(logger_settings.sink);
+        }
 
         spdlog::drop(logger_name);
 

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

@@ -128,14 +128,14 @@ unregister_spdlog_logger(const std::string& n);
  * @return true if all registered loggers have the specified severity level
  */
 bool
-check_log_levels(level level);
+check_log_levels(level lvl);
 
 /**
  * Set the log level of all registered spdLoggers
  * @param log severity level
  */
 void
-set_log_levels(level level);
+set_log_levels(level lvl);
 
 /**
  * Checks whether a specific level should be logged based on the current

package/deps/couchbase-transactions-cxx/deps/couchbase-cxx-client/couchbase/meta/version.cxx

@@ -88,6 +88,13 @@ sdk_build_info()
 #elif defined(SSLEAY_VERSION)
     info["openssl_runtime"] = SSLeay_version(SSLEAY_VERSION);
 #endif
+    info["__cplusplus"] = fmt::format("{}", __cplusplus);
+#if defined(_MSC_VER)
+    info["_MSC_VER"] = fmt::format("{}", _MSC_VER);
+#endif
+#if defined(__GLIBC__)
+    info["libc"] = fmt::format("glibc {}.{}", __GLIBC__, __GLIBC_MINOR__);
+#endif
 
     return info;
 }

package/deps/couchbase-transactions-cxx/deps/couchbase-cxx-client/couchbase/operations/document_append.hxx

@@ -41,9 +41,9 @@ struct append_request {
     using encoded_response_type = protocol::client_response<protocol::append_response_body>;
 
     document_id id;
-    std::string value;
-    uint16_t partition{};
-    uint32_t opaque{};
+    std::vector<std::byte> value;
+    std::uint16_t partition{};
+    std::uint32_t opaque{};
     protocol::durability_level durability_level{ protocol::durability_level::none };
     std::optional<std::chrono::milliseconds> timeout{};
     io::retry_context<io::retry_strategy::best_effort> retries{ false };

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

@@ -35,9 +35,6 @@ decrement_request::encode_to(decrement_request::encoded_request_type& encoded, m
         encoded.body().initial_value(0);
         encoded.body().expiry(0xffff'ffff);
     }
-    if (preserve_expiry) {
-        encoded.body().preserve_expiry();
-    }
     return {};
 }
 

package/deps/couchbase-transactions-cxx/deps/couchbase-cxx-client/couchbase/operations/document_decrement.hxx

@@ -50,7 +50,6 @@ struct decrement_request {
     protocol::durability_level durability_level{ protocol::durability_level::none };
     std::optional<std::chrono::milliseconds> timeout{};
     io::retry_context<io::retry_strategy::best_effort> retries{ false };
-    bool preserve_expiry{ false };
 
     [[nodiscard]] std::error_code encode_to(encoded_request_type& encoded, mcbp_context&& context) const;
 

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

@@ -35,7 +35,7 @@ get_request::make_response(error_context::key_value&& ctx, const encoded_respons
 {
     get_response response{ std::move(ctx) };
     if (!response.ctx.ec) {
-        response.value = std::move(encoded.body().value());
+        response.value = encoded.body().value();
         response.cas = encoded.cas();
         response.flags = encoded.body().flags();
     }

package/deps/couchbase-transactions-cxx/deps/couchbase-cxx-client/couchbase/operations/document_get.hxx

@@ -29,7 +29,7 @@ namespace couchbase::operations
 
 struct get_response {
     error_context::key_value ctx;
-    std::string value{};
+    std::vector<std::byte> value{};
     couchbase::cas cas{};
     std::uint32_t flags{};
 };
@@ -40,8 +40,8 @@ struct get_request {
     using encoded_response_type = protocol::client_response<protocol::get_response_body>;
 
     document_id id;
-    uint16_t partition{};
-    uint32_t opaque{};
+    std::uint16_t partition{};
+    std::uint32_t opaque{};
     std::optional<std::chrono::milliseconds> timeout{};
     io::retry_context<io::retry_strategy::best_effort> retries{ true };
 

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

@@ -36,7 +36,7 @@ get_and_lock_request::make_response(error_context::key_value&& ctx, const encode
 {
     get_and_lock_response response{ std::move(ctx) };
     if (!response.ctx.ec) {
-        response.value = std::move(encoded.body().value());
+        response.value = encoded.body().value();
         response.cas = encoded.cas();
         response.flags = encoded.body().flags();
     }

package/deps/couchbase-transactions-cxx/deps/couchbase-cxx-client/couchbase/operations/document_get_and_lock.hxx

@@ -29,7 +29,7 @@ namespace couchbase::operations
 
 struct get_and_lock_response {
     error_context::key_value ctx;
-    std::string value{};
+    std::vector<std::byte> value{};
     couchbase::cas cas{};
     std::uint32_t flags{};
 };
@@ -40,9 +40,9 @@ struct get_and_lock_request {
     using encoded_response_type = protocol::client_response<protocol::get_and_lock_response_body>;
 
     document_id id;
-    uint16_t partition{};
-    uint32_t opaque{};
-    uint32_t lock_time{};
+    std::uint16_t partition{};
+    std::uint32_t opaque{};
+    std::uint32_t lock_time{};
     std::optional<std::chrono::milliseconds> timeout{};
     io::retry_context<io::retry_strategy::best_effort> retries{ false };
 

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

@@ -36,7 +36,7 @@ get_and_touch_request::make_response(error_context::key_value&& ctx, const encod
 {
     get_and_touch_response response{ std::move(ctx) };
     if (!response.ctx.ec) {
-        response.value = std::move(encoded.body().value());
+        response.value = encoded.body().value();
         response.cas = encoded.cas();
         response.flags = encoded.body().flags();
     }

package/deps/couchbase-transactions-cxx/deps/couchbase-cxx-client/couchbase/operations/document_get_and_touch.hxx

@@ -29,7 +29,7 @@ namespace couchbase::operations
 
 struct get_and_touch_response {
     error_context::key_value ctx;
-    std::string value{};
+    std::vector<std::byte> value{};
     couchbase::cas cas{};
     std::uint32_t flags{};
 };

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

@@ -179,7 +179,10 @@ get_projected_request::make_response(error_context::key_value&& ctx, const encod
             // from full document
             if (projections.empty() && with_expiry) {
                 // special case when user only wanted full+expiration
-                response.value = encoded.body().fields()[1].value;
+                const auto& full_body = encoded.body().fields()[1].value;
+                response.value.resize(full_body.size());
+                std::transform(
+                  full_body.begin(), full_body.end(), response.value.begin(), [](auto ch) { return static_cast<std::byte>(ch); });
             } else {
                 tao::json::value full_doc{};
                 try {
@@ -190,21 +193,21 @@ get_projected_request::make_response(error_context::key_value&& ctx, const encod
                 }
                 tao::json::value new_doc;
                 for (const auto& projection : projections) {
-                    auto value_to_apply = subdoc_lookup(full_doc, projection);
-                    if (value_to_apply) {
+                    if (auto value_to_apply = subdoc_lookup(full_doc, projection)) {
                         subdoc_apply_projection(new_doc, projection, *value_to_apply, preserve_array_indexes);
                     } else {
                         response.ctx.ec = error::key_value_errc::path_not_found;
                         return response;
                     }
                 }
-                response.value = utils::json::generate(new_doc);
+                response.value = utils::json::generate_binary(new_doc);
             }
         } else {
             tao::json::value new_doc = tao::json::empty_object;
             std::size_t offset = with_expiry ? 1 : 0;
             for (const auto& projection : projections) {
-                const auto& field = encoded.body().fields()[offset++];
+                const auto& field = encoded.body().fields()[offset];
+                ++offset;
                 if (field.status == protocol::status::success && !field.value.empty()) {
                     tao::json::value value_to_apply{};
                     try {
@@ -219,7 +222,7 @@ get_projected_request::make_response(error_context::key_value&& ctx, const encod
                     return response;
                 }
             }
-            response.value = utils::json::generate(new_doc);
+            response.value = utils::json::generate_binary(new_doc);
         }
     }
     return response;

package/deps/couchbase-transactions-cxx/deps/couchbase-cxx-client/couchbase/operations/document_get_projected.hxx

@@ -29,7 +29,7 @@ namespace couchbase::operations
 
 struct get_projected_response {
     error_context::key_value ctx;
-    std::string value{};
+    std::vector<std::byte> value{};
     couchbase::cas cas{};
     std::uint32_t flags{};
     std::optional<std::uint32_t> expiry{};

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

@@ -35,9 +35,6 @@ increment_request::encode_to(increment_request::encoded_request_type& encoded, m
         encoded.body().initial_value(0);
         encoded.body().expiry(0xffff'ffff);
     }
-    if (preserve_expiry) {
-        encoded.body().preserve_expiry();
-    }
     return {};
 }
 

package/deps/couchbase-transactions-cxx/deps/couchbase-cxx-client/couchbase/operations/document_increment.hxx

@@ -50,7 +50,6 @@ struct increment_request {
     protocol::durability_level durability_level{ protocol::durability_level::none };
     std::optional<std::chrono::milliseconds> timeout{};
     io::retry_context<io::retry_strategy::best_effort> retries{ false };
-    bool preserve_expiry{ false };
 
     [[nodiscard]] std::error_code encode_to(encoded_request_type& encoded, mcbp_context&& context) const;
 

package/deps/couchbase-transactions-cxx/deps/couchbase-cxx-client/couchbase/operations/document_insert.hxx

@@ -41,11 +41,11 @@ struct insert_request {
     using encoded_response_type = protocol::client_response<protocol::insert_response_body>;
 
     document_id id;
-    std::string value;
-    uint16_t partition{};
-    uint32_t opaque{};
-    uint32_t flags{ 0 };
-    uint32_t expiry{ 0 };
+    std::vector<std::byte> value;
+    std::uint16_t partition{};
+    std::uint32_t opaque{};
+    std::uint32_t flags{ 0 };
+    std::uint32_t expiry{ 0 };
     protocol::durability_level durability_level{ protocol::durability_level::none };
     std::optional<std::chrono::milliseconds> timeout{};
     io::retry_context<io::retry_strategy::best_effort> retries{ false };

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

@@ -53,7 +53,7 @@ lookup_in_request::make_response(error_context::key_value&& ctx, const encoded_r
         for (size_t i = 0; i < specs.entries.size(); ++i) {
             const auto& req_entry = specs.entries[i];
             response.fields[i].original_index = req_entry.original_index;
-            response.fields[i].opcode = protocol::subdoc_opcode(req_entry.opcode);
+            response.fields[i].opcode = static_cast<protocol::subdoc_opcode>(req_entry.opcode);
             response.fields[i].path = req_entry.path;
             response.fields[i].status = protocol::status::success;
         }
@@ -61,7 +61,7 @@ lookup_in_request::make_response(error_context::key_value&& ctx, const encoded_r
             const auto& res_entry = encoded.body().fields()[i];
             response.fields[i].status = res_entry.status;
             response.fields[i].ec =
-              protocol::map_status_code(protocol::client_opcode::subdoc_multi_mutation, std::uint16_t(res_entry.status));
+              protocol::map_status_code(protocol::client_opcode::subdoc_multi_mutation, static_cast<std::uint16_t>(res_entry.status));
             response.fields[i].exists =
               res_entry.status == protocol::status::success || res_entry.status == protocol::status::subdoc_success_deleted;
             response.fields[i].value = res_entry.value;

package/deps/couchbase-transactions-cxx/deps/couchbase-cxx-client/couchbase/operations/document_prepend.hxx

@@ -41,7 +41,7 @@ struct prepend_request {
     using encoded_response_type = protocol::client_response<protocol::prepend_response_body>;
 
     document_id id;
-    std::string value;
+    std::vector<std::byte> value;
     uint16_t partition{};
     uint32_t opaque{};
     protocol::durability_level durability_level{ protocol::durability_level::none };

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

@@ -36,8 +36,7 @@ query_request::encode_to(query_request::encoded_request_type& encoded, http_cont
     if (adhoc) {
         body["statement"] = statement;
     } else {
-        auto entry = ctx_->cache.get(statement);
-        if (entry) {
+        if (auto entry = ctx_->cache.get(statement)) {
             body["prepared"] = entry->name;
             if (entry->plan) {
                 body["encoded_plan"] = entry->plan.value();
@@ -192,6 +191,19 @@ query_request::make_response(error_context::query&& ctx, const encoded_response_
     response.ctx.parameters = body_str;
     response.served_by_node = fmt::format("{}:{}", response.ctx.hostname, response.ctx.port);
     if (!response.ctx.ec) {
+        if (encoded.body.data().empty()) {
+            switch (encoded.status_code) {
+                case 503:
+                    response.ctx.ec = error::common_errc::service_not_available;
+                    break;
+
+                case 500:
+                default:
+                    response.ctx.ec = error::common_errc::internal_server_failure;
+                    break;
+            }
+            return response;
+        }
         tao::json::value payload;
         try {
             payload = utils::json::parse(encoded.body.data());

package/deps/couchbase-transactions-cxx/deps/couchbase-cxx-client/couchbase/operations/document_replace.hxx

@@ -41,7 +41,7 @@ struct replace_request {
     using encoded_response_type = protocol::client_response<protocol::replace_response_body>;
 
     document_id id;
-    std::string value;
+    std::vector<std::byte> value;
     uint16_t partition{};
     uint32_t opaque{};
     uint32_t flags{ 0 };

package/deps/couchbase-transactions-cxx/deps/couchbase-cxx-client/couchbase/operations/document_upsert.hxx

@@ -41,7 +41,7 @@ struct upsert_request {
     using encoded_response_type = protocol::client_response<protocol::upsert_response_body>;
 
     document_id id;
-    std::string value;
+    std::vector<std::byte> value;
     uint16_t partition{};
     uint32_t opaque{};
     uint32_t flags{ 0 };

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

@@ -95,6 +95,9 @@ document_view_request::encode_to(document_view_request::encoded_request_type& en
         }
         body["keys"] = keys_array;
     }
+    for (const auto& [name, value] : raw) {
+        query_string.emplace_back(fmt::format("{}={}", name, value));
+    }
 
     encoded.type = type;
     encoded.method = "POST";

package/deps/couchbase-transactions-cxx/deps/couchbase-cxx-client/couchbase/operations/document_view.hxx

@@ -62,7 +62,7 @@ struct document_view_request {
     std::string bucket_name;
     std::string document_name;
     std::string view_name;
-    design_document_namespace ns;
+    design_document_namespace ns{ design_document_namespace::production };
 
     std::optional<std::uint64_t> limit;
     std::optional<std::uint64_t> skip;
@@ -82,6 +82,7 @@ struct document_view_request {
     std::optional<bool> group;
     std::optional<std::uint32_t> group_level;
     bool debug{ false };
+    std::map<std::string, std::string> raw{};
 
     std::optional<couchbase::view_sort_order> order;
     std::vector<std::string> query_string{};