couchbase 4.1.1 → 4.1.2

package/deps/couchbase-cxx-client/couchbase/protocol/cmd_get_and_touch.cxx

@@ -30,10 +30,10 @@ get_and_touch_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 == 4) {
@@ -53,11 +53,7 @@ get_and_touch_response_body::parse(protocol::status status,
 void
 get_and_touch_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

package/deps/couchbase-cxx-client/couchbase/protocol/cmd_get_and_touch.hxx

@@ -33,19 +33,14 @@ class get_and_touch_response_body
 
   private:
     std::uint32_t flags_;
-    std::string value_;
+    std::vector<std::byte> value_;
 
   public:
-    [[nodiscard]] const std::string& value() const
+    [[nodiscard]] const auto& value() const
     {
         return value_;
     }
 
-    [[nodiscard]] std::string&& value()
-    {
-        return std::move(value_);
-    }
-
     [[nodiscard]] std::uint32_t flags() const
     {
         return flags_;
@@ -56,7 +51,7 @@ class get_and_touch_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);
 };
 
@@ -67,9 +62,9 @@ class get_and_touch_request_body
     static const inline client_opcode opcode = client_opcode::get_and_touch;
 
   private:
-    std::string key_;
+    std::vector<std::byte> key_;
     std::uint32_t expiry_;
-    std::vector<std::uint8_t> extras_{};
+    std::vector<std::byte> extras_{};
 
   public:
     void id(const document_id& id);
@@ -79,17 +74,17 @@ class get_and_touch_request_body
         expiry_ = seconds;
     }
 
-    [[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 empty_buffer;
     }
 
-    [[nodiscard]] const std::vector<std::uint8_t>& extras()
+    [[nodiscard]] const auto& extras()
     {
         if (extras_.empty()) {
             fill_extras();
@@ -97,7 +92,7 @@ class get_and_touch_request_body
         return extras_;
     }
 
-    [[nodiscard]] const std::vector<std::uint8_t>& value() const
+    [[nodiscard]] const auto& value() const
     {
         return empty_buffer;
     }

package/deps/couchbase-cxx-client/couchbase/protocol/cmd_get_cluster_config.cxx

@@ -26,7 +26,7 @@
 namespace couchbase::protocol
 {
 topology::configuration
-parse_config(const std::string& input, std::string_view endpoint_address, uint16_t endpoint_port)
+parse_config(std::string_view input, std::string_view endpoint_address, uint16_t endpoint_port)
 {
     auto config = utils::json::parse(input).as<topology::configuration>();
     for (auto& node : config.nodes) {
@@ -38,7 +38,7 @@ parse_config(const std::string& input, std::string_view endpoint_address, uint16
     // workaround for servers which don't specify this_node
     {
         bool has_this_node = false;
-        for (auto& node : config.nodes) {
+        for (const auto& node : config.nodes) {
             if (node.this_node) {
                 has_this_node = true;
                 break;
@@ -66,16 +66,17 @@ get_cluster_config_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 + key_size + extras_size;
+        std::string_view config_text{ reinterpret_cast<const char*>(body.data()) + offset, body.size() - static_cast<std::size_t>(offset) };
         try {
-            config_ = parse_config(std::string(body.begin() + offset, body.end()), info.endpoint_address, info.endpoint_port);
+            config_ = parse_config(config_text, info.endpoint_address, info.endpoint_port);
         } catch (const tao::pegtl::parse_error& e) {
-            LOG_DEBUG("unable to parse cluster configuration as JSON: {}, {}", e.message(), std::string(body.begin(), body.end()));
+            LOG_DEBUG("unable to parse cluster configuration as JSON: {}, {}", e.message(), config_text);
         }
         return true;
     }

package/deps/couchbase-cxx-client/couchbase/protocol/cmd_get_cluster_config.hxx

@@ -29,7 +29,7 @@ namespace couchbase::protocol
 {
 
 topology::configuration
-parse_config(const std::string& input, std::string_view endpoint_address, uint16_t endpoint_port);
+parse_config(std::string_view input, std::string_view endpoint_address, uint16_t endpoint_port);
 
 class get_cluster_config_response_body
 {
@@ -50,7 +50,7 @@ class get_cluster_config_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);
 };
 
@@ -65,17 +65,17 @@ class get_cluster_config_request_body
         return empty_string;
     }
 
-    [[nodiscard]] const std::vector<std::uint8_t>& framing_extras() const
+    [[nodiscard]] const auto& framing_extras() const
     {
         return empty_buffer;
     }
 
-    [[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 empty_buffer;
     }

package/deps/couchbase-cxx-client/couchbase/protocol/cmd_get_collection_id.cxx

@@ -17,11 +17,14 @@
 
 #include <couchbase/protocol/cmd_get_collection_id.hxx>
 
+#include <couchbase/utils/binary.hxx>
 #include <couchbase/utils/byteswap.hxx>
 
-#include <cstring>
 #include <gsl/assert>
 
+#include <algorithm>
+#include <cstring>
+
 namespace couchbase::protocol
 {
 bool
@@ -30,10 +33,10 @@ get_collection_id_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 && extras_size == 12) {
         std::vector<uint8_t>::difference_type offset = framing_extras_size + key_size;
 
@@ -47,4 +50,11 @@ get_collection_id_response_body::parse(protocol::status status,
     }
     return false;
 }
+
+void
+get_collection_id_request_body::collection_path(const std::string_view& path)
+{
+    value_.reserve(path.size());
+    utils::to_binary(path, std::back_insert_iterator(value_));
+}
 } // namespace couchbase::protocol

package/deps/couchbase-cxx-client/couchbase/protocol/cmd_get_collection_id.hxx

@@ -50,7 +50,7 @@ class get_collection_id_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,30 +61,27 @@ class get_collection_id_request_body
     static const inline client_opcode opcode = client_opcode::get_collection_id;
 
   private:
-    std::vector<std::uint8_t> value_{};
+    std::vector<std::byte> value_{};
 
   public:
-    void collection_path(const std::string_view& path)
-    {
-        value_.assign(path.begin(), path.end());
-    }
+    void collection_path(const std::string_view& path);
 
     [[nodiscard]] const std::string& key() const
     {
         return empty_string;
     }
 
-    [[nodiscard]] const std::vector<std::uint8_t>& framing_extras() const
+    [[nodiscard]] const auto& framing_extras() const
     {
         return empty_buffer;
     }
 
-    [[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 value_;
     }

package/deps/couchbase-cxx-client/couchbase/protocol/cmd_get_collections_manifest.cxx

@@ -17,6 +17,7 @@
 
 #include <couchbase/protocol/cmd_get_collections_manifest.hxx>
 
+#include <couchbase/logger/logger.hxx>
 #include <couchbase/topology/collections_manifest_json.hxx>
 #include <couchbase/utils/json.hxx>
 
@@ -30,13 +31,19 @@ get_collections_manifest_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 + key_size + extras_size;
-        manifest_ = utils::json::parse(std::string(body.begin() + offset, body.end())).as<topology::collections_manifest>();
+        std::string_view manifest_text{ reinterpret_cast<const char*>(body.data()) + offset,
+                                        body.size() - static_cast<std::size_t>(offset) };
+        try {
+            manifest_ = utils::json::parse(manifest_text).as<topology::collections_manifest>();
+        } catch (const tao::pegtl::parse_error& e) {
+            LOG_DEBUG("unable to parse collections manifest as JSON: {}, {}", e.message(), manifest_text);
+        }
         return true;
     }
     return false;

package/deps/couchbase-cxx-client/couchbase/protocol/cmd_get_collections_manifest.hxx

@@ -45,7 +45,7 @@ class get_collections_manifest_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);
 };
 
@@ -60,17 +60,17 @@ class get_collections_manifest_request_body
         return empty_string;
     }
 
-    [[nodiscard]] const std::vector<std::uint8_t>& framing_extras() const
+    [[nodiscard]] const auto& framing_extras() const
     {
         return empty_buffer;
     }
 
-    [[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 empty_buffer;
     }

package/deps/couchbase-cxx-client/couchbase/protocol/cmd_get_error_map.cxx

@@ -33,16 +33,18 @@ get_error_map_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 + key_size + extras_size;
+        std::string_view error_map_text{ reinterpret_cast<const char*>(body.data()) + offset,
+                                         body.size() - static_cast<std::size_t>(offset) };
         try {
-            std::vector<uint8_t>::difference_type offset = framing_extras_size + key_size + extras_size;
-            errmap_ = utils::json::parse(std::string(body.begin() + offset, body.end())).as<error_map>();
+            errmap_ = utils::json::parse(error_map_text).as<error_map>();
         } catch (const tao::pegtl::parse_error& e) {
-            LOG_DEBUG("unable to parse error map as JSON: {}, {}", e.message(), std::string(body.begin(), body.end()));
+            LOG_DEBUG("unable to parse error map as JSON: {}, {}", e.message(), error_map_text);
         }
         return true;
     }

package/deps/couchbase-cxx-client/couchbase/protocol/cmd_get_error_map.hxx

@@ -45,7 +45,7 @@ class get_error_map_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);
 };
 
@@ -57,7 +57,7 @@ class get_error_map_request_body
 
   private:
     std::uint16_t version_{ 2 };
-    std::vector<std::uint8_t> value_;
+    std::vector<std::byte> value_;
 
   public:
     void version(std::uint16_t version)
@@ -70,17 +70,17 @@ class get_error_map_request_body
         return empty_string;
     }
 
-    [[nodiscard]] const std::vector<std::uint8_t>& framing_extras() const
+    [[nodiscard]] const auto& framing_extras() const
     {
         return empty_buffer;
     }
 
-    [[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()
+    [[nodiscard]] const auto& value()
     {
         if (value_.empty()) {
             fill_body();

package/deps/couchbase-cxx-client/couchbase/protocol/cmd_get_meta.cxx

@@ -31,10 +31,10 @@ get_meta_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<std::uint8_t>& body,
+                              const std::vector<std::byte>& body,
                               const cmd_info& /* info */)
 {
-    Expects(header[1] == static_cast<std::uint8_t>(opcode));
+    Expects(header[1] == static_cast<std::byte>(opcode));
     if (status == protocol::status::success) {
         std::vector<std::uint8_t>::difference_type offset = framing_extras_size;
         if (extras_size == sizeof(deleted_) + sizeof(flags_) + sizeof(expiry_) + sizeof(sequence_number_) + sizeof(datatype_)) {
@@ -54,7 +54,7 @@ get_meta_response_body::parse(protocol::status status,
             sequence_number_ = utils::byte_swap(sequence_number_);
             offset += 8;
 
-            datatype_ = body[static_cast<std::size_t>(offset)];
+            datatype_ = std::to_integer<std::uint8_t>(body[static_cast<std::size_t>(offset)]);
         }
         return true;
     }
@@ -64,11 +64,7 @@ get_meta_response_body::parse(protocol::status status,
 void
 get_meta_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);
 }
 
 } // namespace couchbase::protocol

package/deps/couchbase-cxx-client/couchbase/protocol/cmd_get_meta.hxx

@@ -70,7 +70,7 @@ class get_meta_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);
 };
 
@@ -81,28 +81,29 @@ class get_meta_request_body
     static const inline client_opcode opcode = client_opcode::get_meta;
 
   private:
-    std::string key_;
-    std::vector<std::uint8_t> extras_{ 0x02 /* format version, supported since Couchbase Server 5.0, includes datatype into response */ };
+    std::vector<std::byte> key_;
+    std::vector<std::byte> extras_{ std::byte{ 0x02 },
+                                    /* format version, supported since Couchbase Server 5.0, includes datatype into response */ };
 
   public:
     void id(const document_id& id);
 
-    [[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 empty_buffer;
     }
 
-    [[nodiscard]] const std::vector<std::uint8_t>& extras() const
+    [[nodiscard]] const auto& extras() const
     {
         return extras_;
     }
 
-    [[nodiscard]] const std::vector<std::uint8_t>& value()
+    [[nodiscard]] const auto& value()
     {
         return empty_buffer;
     }
@@ -111,9 +112,6 @@ class get_meta_request_body
     {
         return extras_.size() + key_.size();
     }
-
-  private:
-    void fill_body();
 };
 
 } // namespace couchbase::protocol

package/deps/couchbase-cxx-client/couchbase/protocol/cmd_hello.cxx

@@ -17,11 +17,14 @@
 
 #include <couchbase/protocol/cmd_hello.hxx>
 
+#include <couchbase/utils/binary.hxx>
 #include <couchbase/utils/byteswap.hxx>
 
-#include <cstring>
 #include <gsl/assert>
 
+#include <algorithm>
+#include <cstring>
+
 namespace couchbase::protocol
 {
 bool
@@ -30,10 +33,10 @@ hello_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 + key_size + extras_size;
         size_t value_size = body.size() - static_cast<std::size_t>(offset);
@@ -59,8 +62,15 @@ hello_request_body::fill_body()
 {
     value_.resize(2 * features_.size());
     for (std::size_t idx = 0; idx < features_.size(); idx++) {
-        value_[idx * 2] = 0; // we don't need this byte while feature codes fit the 8-bit
-        value_[idx * 2 + 1] = static_cast<uint8_t>(features_[idx]);
+        value_[idx * 2] = std::byte{ 0 }; // we don't need this byte while feature codes fit the 8-bit
+        value_[idx * 2 + 1] = static_cast<std::byte>(features_[idx]);
     }
 }
+
+void
+hello_request_body::user_agent(std::string_view val)
+{
+    key_.reserve(val.size());
+    utils::to_binary(val, std::back_insert_iterator(key_));
+}
 } // namespace couchbase::protocol

package/deps/couchbase-cxx-client/couchbase/protocol/cmd_hello.hxx

@@ -45,7 +45,7 @@ class hello_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);
 };
 
@@ -56,7 +56,7 @@ class hello_request_body
     static const inline client_opcode opcode = client_opcode::hello;
 
   private:
-    std::string key_;
+    std::vector<std::byte> key_;
     std::vector<hello_feature> features_{
         hello_feature::tcp_nodelay,
         hello_feature::mutation_seqno,
@@ -73,18 +73,10 @@ class hello_request_body
         hello_feature::subdoc_create_as_deleted,
         hello_feature::preserve_ttl,
     };
-    std::vector<std::uint8_t> value_;
+    std::vector<std::byte> value_;
 
   public:
-    void user_agent(std::string val)
-    {
-        key_ = std::move(val);
-    }
-
-    [[nodiscard]] const std::string& user_agent() const
-    {
-        return key_;
-    }
+    void user_agent(std::string_view val);
 
     void enable_unordered_execution()
     {
@@ -106,22 +98,22 @@ class hello_request_body
         return features_;
     }
 
-    [[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 empty_buffer;
     }
 
-    [[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()
+    [[nodiscard]] const auto& value()
     {
         if (value_.empty()) {
             fill_body();

package/deps/couchbase-cxx-client/couchbase/protocol/cmd_increment.cxx

@@ -17,7 +17,7 @@
 
 #include <couchbase/protocol/cmd_increment.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,12 +32,12 @@ increment_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) {
-        using offset_type = std::vector<uint8_t>::difference_type;
+        using offset_type = std::vector<std::byte>::difference_type;
         offset_type offset = framing_extras_size;
         if (extras_size == 16) {
             memcpy(&token_.partition_uuid, body.data() + offset, sizeof(token_.partition_uuid));
@@ -59,11 +59,7 @@ increment_response_body::parse(protocol::status status,
 void
 increment_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
@@ -72,26 +68,15 @@ increment_request_body::durability(protocol::durability_level level, std::option
     if (level == protocol::durability_level::none) {
         return;
     }
-    auto frame_id = static_cast<uint8_t>(protocol::request_frame_info_id::durability_requirement);
-    auto extras_size = framing_extras_.size();
-    if (timeout) {
-        framing_extras_.resize(extras_size + 4);
-        framing_extras_[extras_size + 0] = static_cast<std::uint8_t>((static_cast<std::uint32_t>(frame_id) << 4U) | 3U);
-        framing_extras_[extras_size + 1] = static_cast<std::uint8_t>(level);
-        uint16_t val = utils::byte_swap(*timeout);
-        memcpy(framing_extras_.data() + extras_size + 2, &val, sizeof(val));
-    } else {
-        framing_extras_.resize(extras_size + 2);
-        framing_extras_[extras_size + 0] = static_cast<std::uint8_t>(static_cast<std::uint32_t>(frame_id) << 4U | 1U);
-        framing_extras_[extras_size + 1] = static_cast<std::uint8_t>(level);
-    }
+
+    add_durability_frame_info(framing_extras_, level, timeout);
 }
 
 void
 increment_request_body::fill_extras()
 {
     extras_.resize(sizeof(delta_) + sizeof(initial_value_) + sizeof(expiry_));
-    using offset_type = std::vector<uint8_t>::difference_type;
+    using offset_type = std::vector<std::byte>::difference_type;
     offset_type offset = 0;
 
     std::uint64_t num = utils::byte_swap(delta_);