couchbase 4.0.0 → 4.1.2

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

@@ -19,11 +19,12 @@
 
 #include <couchbase/error_context/key_value.hxx>
 #include <couchbase/io/mcbp_context.hxx>
+#include <couchbase/io/mcbp_traits.hxx>
 #include <couchbase/io/retry_context.hxx>
 #include <couchbase/protocol/client_request.hxx>
-#include <couchbase/timeout_defaults.hxx>
-#include <couchbase/protocol/durability_level.hxx>
 #include <couchbase/protocol/cmd_decrement.hxx>
+#include <couchbase/protocol/durability_level.hxx>
+#include <couchbase/timeout_defaults.hxx>
 
 namespace couchbase::operations
 {
@@ -31,7 +32,7 @@ namespace couchbase::operations
 struct decrement_response {
     error_context::key_value ctx;
     std::uint64_t content{};
-    protocol::cas cas{};
+    couchbase::cas cas{};
     mutation_token token{};
 };
 
@@ -47,10 +48,8 @@ struct decrement_request {
     std::uint64_t delta{ 1 };
     std::optional<std::uint64_t> initial_value{};
     protocol::durability_level durability_level{ protocol::durability_level::none };
-    std::optional<std::uint16_t> durability_timeout{};
     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;
 
@@ -58,3 +57,10 @@ struct decrement_request {
 };
 
 } // namespace couchbase::operations
+
+namespace couchbase::io::mcbp_traits
+{
+template<>
+struct supports_durability<couchbase::operations::decrement_request> : public std::true_type {
+};
+} // namespace couchbase::io::mcbp_traits

package/deps/couchbase-cxx-client/couchbase/operations/document_exists.hxx

@@ -21,8 +21,8 @@
 #include <couchbase/io/mcbp_context.hxx>
 #include <couchbase/io/retry_context.hxx>
 #include <couchbase/protocol/client_request.hxx>
-#include <couchbase/timeout_defaults.hxx>
 #include <couchbase/protocol/cmd_get_meta.hxx>
+#include <couchbase/timeout_defaults.hxx>
 
 namespace couchbase::operations
 {
@@ -30,7 +30,7 @@ namespace couchbase::operations
 struct exists_response {
     error_context::key_value ctx;
     bool deleted{};
-    protocol::cas cas{};
+    couchbase::cas cas{};
     std::uint32_t flags{};
     std::uint32_t expiry{};
     std::uint64_t sequence_number{};

package/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-cxx-client/couchbase/operations/document_get.hxx

@@ -29,8 +29,8 @@ namespace couchbase::operations
 
 struct get_response {
     error_context::key_value ctx;
-    std::string value{};
-    protocol::cas cas{};
+    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-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-cxx-client/couchbase/operations/document_get_and_lock.hxx

@@ -29,8 +29,8 @@ namespace couchbase::operations
 
 struct get_and_lock_response {
     error_context::key_value ctx;
-    std::string value{};
-    protocol::cas cas{};
+    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-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-cxx-client/couchbase/operations/document_get_and_touch.hxx

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

package/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-cxx-client/couchbase/operations/document_get_projected.hxx

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

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

@@ -35,12 +35,6 @@ increment_request::encode_to(increment_request::encoded_request_type& encoded, m
         encoded.body().initial_value(0);
         encoded.body().expiry(0xffff'ffff);
     }
-    if (durability_level != protocol::durability_level::none) {
-        encoded.body().durability(durability_level, durability_timeout);
-    }
-    if (preserve_expiry) {
-        encoded.body().preserve_expiry();
-    }
     return {};
 }
 

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

@@ -19,6 +19,7 @@
 
 #include <couchbase/error_context/key_value.hxx>
 #include <couchbase/io/mcbp_context.hxx>
+#include <couchbase/io/mcbp_traits.hxx>
 #include <couchbase/io/retry_context.hxx>
 #include <couchbase/protocol/client_request.hxx>
 #include <couchbase/protocol/cmd_increment.hxx>
@@ -31,7 +32,7 @@ namespace couchbase::operations
 struct increment_response {
     error_context::key_value ctx;
     std::uint64_t content{};
-    protocol::cas cas{};
+    couchbase::cas cas{};
     mutation_token token{};
 };
 
@@ -47,10 +48,8 @@ struct increment_request {
     std::uint64_t delta{ 1 };
     std::optional<std::uint64_t> initial_value{};
     protocol::durability_level durability_level{ protocol::durability_level::none };
-    std::optional<std::uint16_t> durability_timeout{};
     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;
 
@@ -58,3 +57,10 @@ struct increment_request {
 };
 
 } // namespace couchbase::operations
+
+namespace couchbase::io::mcbp_traits
+{
+template<>
+struct supports_durability<couchbase::operations::increment_request> : public std::true_type {
+};
+} // namespace couchbase::io::mcbp_traits

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

@@ -30,9 +30,6 @@ insert_request::encode_to(insert_request::encoded_request_type& encoded, mcbp_co
     encoded.body().expiry(expiry);
     encoded.body().flags(flags);
     encoded.body().content(value);
-    if (durability_level != protocol::durability_level::none) {
-        encoded.body().durability(durability_level, durability_timeout);
-    }
     return {};
 }
 

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

@@ -19,6 +19,7 @@
 
 #include <couchbase/error_context/key_value.hxx>
 #include <couchbase/io/mcbp_context.hxx>
+#include <couchbase/io/mcbp_traits.hxx>
 #include <couchbase/io/retry_context.hxx>
 #include <couchbase/protocol/client_request.hxx>
 #include <couchbase/protocol/cmd_insert.hxx>
@@ -30,7 +31,7 @@ namespace couchbase::operations
 
 struct insert_response {
     error_context::key_value ctx;
-    protocol::cas cas{};
+    couchbase::cas cas{};
     mutation_token token{};
 };
 
@@ -40,13 +41,12 @@ 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::uint16_t> durability_timeout{};
     std::optional<std::chrono::milliseconds> timeout{};
     io::retry_context<io::retry_strategy::best_effort> retries{ false };
 
@@ -56,3 +56,10 @@ struct insert_request {
 };
 
 } // namespace couchbase::operations
+
+namespace couchbase::io::mcbp_traits
+{
+template<>
+struct supports_durability<couchbase::operations::insert_request> : public std::true_type {
+};
+} // namespace couchbase::io::mcbp_traits

package/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-cxx-client/couchbase/operations/document_lookup_in.hxx

@@ -38,7 +38,7 @@ struct lookup_in_response {
         std::error_code ec{};
     };
     error_context::key_value ctx;
-    protocol::cas cas{};
+    couchbase::cas cas{};
     std::vector<field> fields{};
     bool deleted{ false };
 };

package/deps/couchbase-cxx-client/couchbase/operations/document_mutate_in.cxx

@@ -51,9 +51,6 @@ mutate_in_request::encode_to(mutate_in_request::encoded_request_type& encoded, m
     encoded.body().create_as_deleted(create_as_deleted);
     encoded.body().store_semantics(store_semantics);
     encoded.body().specs(specs);
-    if (durability_level != protocol::durability_level::none) {
-        encoded.body().durability(durability_level, durability_timeout);
-    }
     if (preserve_expiry) {
         encoded.body().preserve_expiry();
     }

package/deps/couchbase-cxx-client/couchbase/operations/document_mutate_in.hxx

@@ -19,11 +19,12 @@
 
 #include <couchbase/error_context/key_value.hxx>
 #include <couchbase/io/mcbp_context.hxx>
+#include <couchbase/io/mcbp_traits.hxx>
 #include <couchbase/io/retry_context.hxx>
 #include <couchbase/protocol/client_request.hxx>
-#include <couchbase/timeout_defaults.hxx>
-#include <couchbase/protocol/durability_level.hxx>
 #include <couchbase/protocol/cmd_mutate_in.hxx>
+#include <couchbase/protocol/durability_level.hxx>
+#include <couchbase/timeout_defaults.hxx>
 
 namespace couchbase::operations
 {
@@ -38,7 +39,7 @@ struct mutate_in_response {
         std::error_code ec{};
     };
     error_context::key_value ctx;
-    protocol::cas cas{};
+    couchbase::cas cas{};
     mutation_token token{};
     std::vector<field> fields{};
     std::optional<std::size_t> first_error_index{};
@@ -53,7 +54,7 @@ struct mutate_in_request {
     document_id id;
     uint16_t partition{};
     uint32_t opaque{};
-    protocol::cas cas{ 0 };
+    couchbase::cas cas{ 0 };
     bool access_deleted{ false };
     bool create_as_deleted{ false };
     std::optional<std::uint32_t> expiry{};
@@ -62,7 +63,6 @@ struct mutate_in_request {
     };
     protocol::mutate_in_request_body::mutate_in_specs specs{};
     protocol::durability_level durability_level{ protocol::durability_level::none };
-    std::optional<std::uint16_t> durability_timeout{};
     std::optional<std::chrono::milliseconds> timeout{};
     io::retry_context<io::retry_strategy::best_effort> retries{ false };
     bool preserve_expiry{ false };
@@ -73,3 +73,10 @@ struct mutate_in_request {
 };
 
 } // namespace couchbase::operations
+
+namespace couchbase::io::mcbp_traits
+{
+template<>
+struct supports_durability<couchbase::operations::mutate_in_request> : public std::true_type {
+};
+} // namespace couchbase::io::mcbp_traits

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

@@ -28,9 +28,6 @@ prepend_request::encode_to(prepend_request::encoded_request_type& encoded, mcbp_
     encoded.partition(partition);
     encoded.body().id(id);
     encoded.body().content(value);
-    if (durability_level != protocol::durability_level::none) {
-        encoded.body().durability(durability_level, durability_timeout);
-    }
     return {};
 }
 

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

@@ -19,6 +19,7 @@
 
 #include <couchbase/error_context/key_value.hxx>
 #include <couchbase/io/mcbp_context.hxx>
+#include <couchbase/io/mcbp_traits.hxx>
 #include <couchbase/io/retry_context.hxx>
 #include <couchbase/protocol/client_request.hxx>
 #include <couchbase/protocol/cmd_prepend.hxx>
@@ -30,7 +31,7 @@ namespace couchbase::operations
 
 struct prepend_response {
     error_context::key_value ctx;
-    protocol::cas cas{};
+    couchbase::cas cas{};
     mutation_token token{};
 };
 
@@ -40,11 +41,10 @@ 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 };
-    std::optional<std::uint16_t> durability_timeout{};
     std::optional<std::chrono::milliseconds> timeout{};
     io::retry_context<io::retry_strategy::best_effort> retries{ false };
 
@@ -54,3 +54,10 @@ struct prepend_request {
 };
 
 } // namespace couchbase::operations
+
+namespace couchbase::io::mcbp_traits
+{
+template<>
+struct supports_durability<couchbase::operations::prepend_request> : public std::true_type {
+};
+} // namespace couchbase::io::mcbp_traits

package/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();
@@ -74,13 +73,13 @@ query_request::encode_to(query_request::encoded_request_type& encoded, http_cont
         body["args"] = std::move(parameters);
     }
     switch (profile) {
-        case profile_mode::phases:
+        case couchbase::query_profile_mode::phases:
             body["profile"] = "phases";
             break;
-        case profile_mode::timings:
+        case couchbase::query_profile_mode::timings:
             body["profile"] = "timings";
             break;
-        case profile_mode::off:
+        case couchbase::query_profile_mode::off:
             break;
     }
     if (max_parallelism) {
@@ -110,10 +109,10 @@ query_request::encode_to(query_request::encoded_request_type& encoded, http_cont
     bool check_scan_wait = false;
     if (scan_consistency) {
         switch (scan_consistency.value()) {
-            case scan_consistency_type::not_bounded:
+            case couchbase::query_scan_consistency::not_bounded:
                 body["scan_consistency"] = "not_bounded";
                 break;
-            case scan_consistency_type::request_plus:
+            case couchbase::query_scan_consistency::request_plus:
                 check_scan_wait = true;
                 body["scan_consistency"] = "request_plus";
                 break;
@@ -190,8 +189,21 @@ query_request::make_response(error_context::query&& ctx, const encoded_response_
     query_response response{ std::move(ctx) };
     response.ctx.statement = statement;
     response.ctx.parameters = body_str;
-    response.served_by_node = response.ctx.last_dispatched_to.value_or("");
+    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-cxx-client/couchbase/operations/document_query.hxx

@@ -22,8 +22,10 @@
 #include <couchbase/io/http_message.hxx>
 #include <couchbase/io/http_traits.hxx>
 #include <couchbase/json_string.hxx>
+#include <couchbase/mutation_token.hxx>
 #include <couchbase/platform/uuid.h>
-#include <couchbase/protocol/mutation_token.hxx>
+#include <couchbase/query_profile_mode.hxx>
+#include <couchbase/query_scan_consistency.hxx>
 #include <couchbase/timeout_defaults.hxx>
 
 namespace couchbase::operations
@@ -71,8 +73,6 @@ struct query_request {
     using encoded_response_type = io::http_response;
     using error_context_type = error_context::query;
 
-    enum class scan_consistency_type { not_bounded, request_plus };
-
     static const inline service_type type = service_type::query;
 
     std::string statement;
@@ -88,7 +88,7 @@ struct query_request {
     std::optional<std::chrono::milliseconds> scan_wait{};
     std::optional<std::uint64_t> pipeline_batch{};
     std::optional<std::uint64_t> pipeline_cap{};
-    std::optional<scan_consistency_type> scan_consistency{};
+    std::optional<couchbase::query_scan_consistency> scan_consistency{};
     std::vector<mutation_token> mutation_state{};
     std::optional<std::string> bucket_name{};
     std::optional<std::string> scope_name{};
@@ -96,12 +96,7 @@ struct query_request {
     std::optional<std::string> client_context_id{};
     std::optional<std::chrono::milliseconds> timeout{};
 
-    enum class profile_mode {
-        off,
-        phases,
-        timings,
-    };
-    profile_mode profile{ profile_mode::off };
+    couchbase::query_profile_mode profile{ couchbase::query_profile_mode::off };
 
     std::map<std::string, couchbase::json_string> raw{};
     std::vector<couchbase::json_string> positional_parameters{};

package/deps/couchbase-cxx-client/couchbase/operations/document_remove.cxx

@@ -28,9 +28,6 @@ remove_request::encode_to(remove_request::encoded_request_type& encoded, mcbp_co
     encoded.partition(partition);
     encoded.cas(cas);
     encoded.body().id(id);
-    if (durability_level != protocol::durability_level::none) {
-        encoded.body().durability(durability_level, durability_timeout);
-    }
     return {};
 }
 

package/deps/couchbase-cxx-client/couchbase/operations/document_remove.hxx

@@ -19,6 +19,7 @@
 
 #include <couchbase/error_context/key_value.hxx>
 #include <couchbase/io/mcbp_context.hxx>
+#include <couchbase/io/mcbp_traits.hxx>
 #include <couchbase/io/retry_context.hxx>
 #include <couchbase/protocol/client_request.hxx>
 #include <couchbase/protocol/cmd_remove.hxx>
@@ -30,7 +31,7 @@ namespace couchbase::operations
 
 struct remove_response {
     error_context::key_value ctx;
-    protocol::cas cas{};
+    couchbase::cas cas{};
     mutation_token token{};
 };
 
@@ -42,9 +43,8 @@ struct remove_request {
     document_id id;
     uint16_t partition{};
     uint32_t opaque{};
-    protocol::cas cas{ 0 };
+    couchbase::cas cas{ 0 };
     protocol::durability_level durability_level{ protocol::durability_level::none };
-    std::optional<std::uint16_t> durability_timeout{};
     std::optional<std::chrono::milliseconds> timeout{};
     io::retry_context<io::retry_strategy::best_effort> retries{ false };
 
@@ -54,3 +54,10 @@ struct remove_request {
 };
 
 } // namespace couchbase::operations
+
+namespace couchbase::io::mcbp_traits
+{
+template<>
+struct supports_durability<couchbase::operations::remove_request> : public std::true_type {
+};
+} // namespace couchbase::io::mcbp_traits

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

@@ -31,9 +31,6 @@ replace_request::encode_to(replace_request::encoded_request_type& encoded, mcbp_
     encoded.body().expiry(expiry);
     encoded.body().flags(flags);
     encoded.body().content(value);
-    if (durability_level != protocol::durability_level::none) {
-        encoded.body().durability(durability_level, durability_timeout);
-    }
     if (preserve_expiry) {
         encoded.body().preserve_expiry();
     }