couchbase 4.1.1 → 4.1.2

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

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

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

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

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

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

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

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

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

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

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

@@ -17,7 +17,7 @@
 
 #include <couchbase/protocol/cmd_decrement.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>
 
@@ -31,12 +31,12 @@ decrement_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));
@@ -58,11 +58,7 @@ decrement_response_body::parse(protocol::status status,
 void
 decrement_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
@@ -71,26 +67,14 @@ decrement_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
 decrement_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_);

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

@@ -53,7 +53,7 @@ class decrement_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);
 };
 
@@ -64,12 +64,12 @@ class decrement_request_body
     static const inline client_opcode opcode = client_opcode::decrement;
 
   private:
-    std::string key_;
-    std::vector<std::uint8_t> framing_extras_{};
+    std::vector<std::byte> key_;
+    std::vector<std::byte> framing_extras_{};
     std::uint64_t delta_{ 1 };
     std::uint64_t initial_value_{ 0 };
     std::uint32_t expiry_{ 0 };
-    std::vector<std::uint8_t> extras_{};
+    std::vector<std::byte> extras_{};
 
   public:
     void id(const document_id& id);
@@ -91,17 +91,17 @@ class decrement_request_body
 
     void durability(protocol::durability_level level, std::optional<std::uint16_t> timeout);
 
-    [[nodiscard]] const std::string& key() const
+    [[nodiscard]] const auto& key() const
     {
         return key_;
     }
 
-    [[nodiscard]] const std::vector<std::uint8_t>& framing_extras() const
+    [[nodiscard]] const auto& framing_extras() const
     {
         return framing_extras_;
     }
 
-    [[nodiscard]] const std::vector<std::uint8_t>& extras()
+    [[nodiscard]] const auto& extras()
     {
         if (extras_.empty()) {
             fill_extras();
@@ -109,7 +109,7 @@ class decrement_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_exists.cxx

@@ -31,12 +31,12 @@ exists_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) {
-        using offset_type = std::vector<std::uint8_t>::difference_type;
+        using offset_type = std::vector<std::byte>::difference_type;
         offset_type offset = framing_extras_size + extras_size + key_size;
 
         memcpy(&partition_id_, body.data() + offset, sizeof(partition_id_));
@@ -52,7 +52,7 @@ exists_response_body::parse(protocol::status status,
         memcpy(key_.data(), body.data() + offset, key_len);
         offset += key_len;
 
-        status_ = body[static_cast<std::size_t>(offset)];
+        status_ = std::to_integer<std::uint8_t>(body[static_cast<std::size_t>(offset)]);
         offset++;
 
         memcpy(&cas_, body.data() + offset, sizeof(cas_));
@@ -65,17 +65,13 @@ void
 exists_request_body::id(std::uint16_t partition_id, const document_id& id)
 {
     partition_id_ = partition_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
 exists_request_body::fill_body()
 {
-    std::vector<std::uint8_t>::size_type offset = 0;
+    std::vector<std::byte>::size_type offset = 0;
 
     value_.resize(2 * sizeof(std::uint16_t) + key_.size());
 

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

@@ -34,7 +34,7 @@ class exists_response_body
 
   private:
     std::uint16_t partition_id_;
-    std::string key_;
+    std::vector<std::byte> key_;
     std::uint8_t status_;
     std::uint64_t cas_;
 
@@ -49,7 +49,7 @@ class exists_response_body
         return couchbase::cas{ cas_ };
     }
 
-    [[nodiscard]] const std::string& key() const
+    [[nodiscard]] const auto& key() const
     {
         return key_;
     }
@@ -64,7 +64,7 @@ class exists_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);
 };
 
@@ -76,8 +76,8 @@ class exists_request_body
 
   private:
     std::uint16_t partition_id_;
-    std::string key_;
-    std::vector<std::uint8_t> value_{};
+    std::vector<std::byte> key_;
+    std::vector<std::byte> value_{};
 
   public:
     void id(std::uint16_t partition_id, const document_id& id);
@@ -88,17 +88,17 @@ class exists_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.cxx

@@ -31,10 +31,10 @@ get_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) {
@@ -54,10 +54,6 @@ get_response_body::parse(protocol::status status,
 void
 get_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.hxx

@@ -33,19 +33,14 @@ class get_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_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,27 +62,27 @@ class get_request_body
     static const inline client_opcode opcode = client_opcode::get;
 
   private:
-    std::string key_;
+    std::vector<std::byte> key_;
 
   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 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_and_lock.cxx

@@ -30,10 +30,10 @@ get_and_lock_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) {
@@ -49,15 +49,13 @@ get_and_lock_response_body::parse(protocol::status status,
     }
     return false;
 }
+
 void
 get_and_lock_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
 get_and_lock_request_body::fill_extras()
 {

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

@@ -33,19 +33,14 @@ class get_and_lock_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_lock_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_lock_request_body
     static const inline client_opcode opcode = client_opcode::get_and_lock;
 
   private:
-    std::string key_;
+    std::vector<std::byte> key_;
     std::uint32_t lock_time_;
-    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_lock_request_body
         lock_time_ = 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_lock_request_body
         return extras_;
     }
 
-    [[nodiscard]] const std::vector<std::uint8_t>& value() const
+    [[nodiscard]] const auto& value() const
     {
         return empty_buffer;
     }