couchbase 4.4.1 → 4.4.3

package/deps/couchbase-cxx-client/core/crypto/cbcrypto.h

@@ -27,8 +27,8 @@ enum class Algorithm {
   ALG_SHA512
 };
 
-bool
-isSupported(Algorithm algorithm);
+auto
+isSupported(Algorithm algorithm) -> bool;
 
 const int SHA1_DIGEST_SIZE = 20;
 const int SHA256_DIGEST_SIZE = 32;
@@ -41,8 +41,8 @@ const int SHA512_DIGEST_SIZE = 64;
  * @throws std::invalid_argument - unsupported algorithm
  *         std::runtime_error - Failures generating the HMAC
  */
-std::string
-CBC_HMAC(Algorithm algorithm, std::string_view key, std::string_view data);
+auto
+CBC_HMAC(Algorithm algorithm, std::string_view key, std::string_view data) -> std::string;
 
 /**
  * Generate a PBKDF2_HMAC digest of the key and data by using the given
@@ -51,24 +51,24 @@ CBC_HMAC(Algorithm algorithm, std::string_view key, std::string_view data);
  * @throws std::invalid_argument - unsupported algorithm
  *         std::runtime_error - Failures generating the HMAC
  */
-std::string
+auto
 PBKDF2_HMAC(Algorithm algorithm,
             const std::string& pass,
             std::string_view salt,
-            unsigned int iterationCount);
+            unsigned int iterationCount) -> std::string;
 
 /**
  * Generate a digest by using the requested algorithm
  */
-std::string
-digest(Algorithm algorithm, std::string_view data);
+auto
+digest(Algorithm algorithm, std::string_view data) -> std::string;
 
 enum class Cipher {
   AES_256_cbc
 };
 
-Cipher
-to_cipher(const std::string& str);
+auto
+to_cipher(const std::string& str) -> Cipher;
 
 /**
  * Encrypt the specified data by using a given cipher
@@ -79,8 +79,9 @@ to_cipher(const std::string& str);
  * @param data The Pointer to the data to encrypt
  * @return The encrypted data
  */
-std::string
-encrypt(Cipher cipher, std::string_view key, std::string_view iv, std::string_view data);
+auto
+encrypt(Cipher cipher, std::string_view key, std::string_view iv, std::string_view data)
+  -> std::string;
 
 /**
  * Decrypt the specified data by using a given cipher
@@ -91,7 +92,8 @@ encrypt(Cipher cipher, std::string_view key, std::string_view iv, std::string_vi
  * @param data The data to decrypt
  * @return The decrypted data
  */
-std::string
-decrypt(Cipher cipher, std::string_view key, std::string_view iv, std::string_view data);
+auto
+decrypt(Cipher cipher, std::string_view key, std::string_view iv, std::string_view data)
+  -> std::string;
 
 } // namespace couchbase::core::crypto

package/deps/couchbase-cxx-client/core/diagnostics_json.hxx

@@ -22,7 +22,7 @@
 #include "diagnostics_fmt.hxx"
 #include "service_type_fmt.hxx"
 
-#include <tao/json/forward.hpp>
+#include <tao/json/value.hpp>
 
 namespace tao::json
 {

package/deps/couchbase-cxx-client/core/error_context/http_json.hxx

@@ -23,7 +23,7 @@
 #include <couchbase/error_codes.hxx>
 #include <couchbase/fmt/retry_reason.hxx>
 
-#include <tao/json/forward.hpp>
+#include <tao/json/value.hpp>
 
 namespace tao::json
 {

package/deps/couchbase-cxx-client/core/free_form_http_request.cxx

@@ -15,6 +15,7 @@
 
 #include "free_form_http_request.hxx"
 
+#include "io/http_message.hxx"
 #include "io/http_streaming_response.hxx"
 #include "utils/movable_function.hxx"
 
@@ -69,6 +70,41 @@ private:
   io::http_streaming_response streaming_resp_;
 };
 
+class buffered_http_response_impl
+{
+public:
+  explicit buffered_http_response_impl(io::http_response resp)
+    : resp_{ std::move(resp) }
+  {
+  }
+
+  [[nodiscard]] auto endpoint() const -> std::string
+  {
+    return {};
+  }
+
+  [[nodiscard]] auto status_code() const -> std::uint32_t
+  {
+    return resp_.status_code;
+  }
+
+  [[nodiscard]] auto content_length() const -> std::size_t
+  {
+    if (resp_.headers.find("content-length") == resp_.headers.end()) {
+      return 0;
+    }
+    return std::stoul(resp_.headers.at("content-length"));
+  }
+
+  [[nodiscard]] auto body() const -> std::string
+  {
+    return resp_.body.data();
+  }
+
+private:
+  io::http_response resp_;
+};
+
 http_response::http_response(io::http_streaming_response resp)
   : impl_{ std::make_shared<http_response_impl>(std::move(resp)) }
 {
@@ -93,7 +129,7 @@ http_response::content_length() const -> std::size_t
 auto
 http_response::body() const -> http_response_body
 {
-  return { impl_ };
+  return http_response_body{ impl_ };
 }
 
 void
@@ -118,4 +154,32 @@ http_response_body::next(utils::movable_function<void(std::string, std::error_co
 {
   return impl_->next_body(std::move(callback));
 }
+
+buffered_http_response::buffered_http_response(io::http_response resp)
+  : impl_{ std::make_shared<buffered_http_response_impl>(std::move(resp)) }
+{
+}
+
+auto
+buffered_http_response::endpoint() const -> std::string
+{
+  return impl_->endpoint();
+}
+auto
+buffered_http_response::status_code() const -> std::uint32_t
+{
+  return impl_->status_code();
+}
+auto
+buffered_http_response::content_length() const -> std::size_t
+{
+  return impl_->content_length();
+}
+
+auto
+buffered_http_response::body() -> std::string
+{
+  return impl_->body();
+}
+
 } // namespace couchbase::core

package/deps/couchbase-cxx-client/core/free_form_http_request.hxx

@@ -15,6 +15,9 @@
 
 #pragma once
 
+#include <couchbase/build_config.hxx>
+
+#include "core/impl/bootstrap_error.hxx"
 #include "service_type.hxx"
 #include "utils/movable_function.hxx"
 
@@ -55,7 +58,7 @@ public:
   bool is_read_only{};
   std::string unique_id{};
   std::shared_ptr<couchbase::retry_strategy> retry_strategy{};
-  std::optional<std::chrono::milliseconds> timeout{};
+  std::chrono::milliseconds timeout{};
   std::shared_ptr<couchbase::tracing::request_span> parent_span{};
 
   struct {
@@ -67,6 +70,7 @@ public:
 namespace io
 {
 class http_streaming_response;
+struct http_response;
 } // namespace io
 
 class http_response_impl;
@@ -74,7 +78,7 @@ class http_response_impl;
 class http_response_body
 {
 public:
-  http_response_body(std::shared_ptr<http_response_impl> impl);
+  explicit http_response_body(std::shared_ptr<http_response_impl> impl);
 
   void next(utils::movable_function<void(std::string, std::error_code)> callback);
   void cancel();
@@ -87,20 +91,45 @@ class http_response
 {
 public:
   http_response() = default;
-  http_response(io::http_streaming_response resp);
+  explicit http_response(io::http_streaming_response resp);
 
-  auto endpoint() const -> std::string;
-  auto status_code() const -> std::uint32_t;
-  auto content_length() const -> std::size_t;
+  [[nodiscard]] auto endpoint() const -> std::string;
+  [[nodiscard]] auto status_code() const -> std::uint32_t;
+  [[nodiscard]] auto content_length() const -> std::size_t;
 
-  auto body() const -> http_response_body;
+  [[nodiscard]] auto body() const -> http_response_body;
   void close();
 
 private:
   std::shared_ptr<http_response_impl> impl_;
 };
 
+#ifdef COUCHBASE_CXX_CLIENT_COLUMNAR
+using free_form_http_request_callback =
+  utils::movable_function<void(http_response response, couchbase::core::error_union err)>;
+#else
 using free_form_http_request_callback =
   utils::movable_function<void(http_response response, std::error_code ec)>;
+#endif
+
+class buffered_http_response_impl;
+
+class buffered_http_response
+{
+public:
+  buffered_http_response() = default;
+  explicit buffered_http_response(io::http_response resp);
+
+  [[nodiscard]] auto endpoint() const -> std::string;
+  [[nodiscard]] auto status_code() const -> std::uint32_t;
+  [[nodiscard]] auto content_length() const -> std::size_t;
+
+  [[nodiscard]] auto body() -> std::string;
+
+private:
+  std::shared_ptr<buffered_http_response_impl> impl_;
+};
 
+using buffered_free_form_http_request_callback =
+  utils::movable_function<void(buffered_http_response response, std::error_code ec)>;
 } // namespace couchbase::core