couchbase 4.3.1 → 4.4.1-dev.1

package/deps/couchbase-cxx-client/core/impl/expiry.cxx

@@ -22,78 +22,91 @@
 
 namespace couchbase::core::impl
 {
-// Durations longer than this must be converted to an epoch second before being passed to the server.
+// Durations longer than this must be converted to an epoch second before being passed to the
+// server.
 constexpr std::chrono::seconds relative_expiry_cutoff_seconds{ 30 * 24 * 60 * 60 };
 
 // Avoid ambiguity duration longer than 50 years this by disallowing such durations.
 constexpr std::chrono::seconds latest_valid_expiry_duration{ 50 * 365 * 24 * 60 * 60 };
 
 // Any time_point earlier than this is almost certainly the result of a programming error.
-// The selected value is > 30 days, so we don't need to worry about instant's epoch second being misinterpreted as a number of seconds from
-// the current time.
-constexpr std::chrono::system_clock::time_point earliest_valid_expiry_time_point{ std::chrono::seconds{ 31 * 24 * 60 * 60 } };
+// The selected value is > 30 days, so we don't need to worry about instant's epoch second being
+// misinterpreted as a number of seconds from the current time.
+constexpr std::chrono::system_clock::time_point earliest_valid_expiry_time_point{
+  std::chrono::seconds{ 31 * 24 * 60 * 60 }
+};
 
-// The server interprets the 32-bit expiry field as an unsigned integer. This means the maximum value is 4294967295 seconds,
-// which corresponds to 2106-02-07T06:28:15Z.
-constexpr std::chrono::system_clock::time_point latest_valid_expiry_time_point{ std::chrono::seconds{
-  std::numeric_limits<std::uint32_t>::max() } };
+// The server interprets the 32-bit expiry field as an unsigned integer. This means the maximum
+// value is 4294967295 seconds, which corresponds to 2106-02-07T06:28:15Z.
+constexpr std::chrono::system_clock::time_point latest_valid_expiry_time_point{
+  std::chrono::seconds{ std::numeric_limits<std::uint32_t>::max() }
+};
 
-std::uint32_t
-expiry_none()
+auto
+expiry_none() -> std::uint32_t
 {
-    return 0;
+  return 0;
 }
 
-std::uint32_t
-expiry_relative(std::chrono::seconds expiry)
+auto
+expiry_relative(std::chrono::seconds expiry) -> std::uint32_t
 {
-    if (expiry == std::chrono::seconds::zero()) {
-        return expiry_none();
-    }
+  if (expiry == std::chrono::seconds::zero()) {
+    return expiry_none();
+  }
 
-    if (expiry > latest_valid_expiry_duration) {
-        throw std::system_error(errc::common::invalid_argument,
-                                fmt::format("When specifying expiry as a duration, it must not be longer than {} seconds, but got {}. If "
-                                            "you truly require a longer expiry, please specify it as an time_point instead.",
-                                            latest_valid_expiry_duration.count(),
-                                            expiry.count()));
-    }
+  if (expiry > latest_valid_expiry_duration) {
+    throw std::system_error(
+      errc::common::invalid_argument,
+      fmt::format("When specifying expiry as a duration, it must not be longer than {} seconds, "
+                  "but got {}. If "
+                  "you truly require a longer expiry, please specify it as an time_point instead.",
+                  latest_valid_expiry_duration.count(),
+                  expiry.count()));
+  }
 
-    if (expiry < relative_expiry_cutoff_seconds) {
-        return static_cast<std::uint32_t>(expiry.count());
-    }
+  if (expiry < relative_expiry_cutoff_seconds) {
+    return static_cast<std::uint32_t>(expiry.count());
+  }
 
-    auto expiry_time_point = std::chrono::system_clock::now() + expiry;
-    if (expiry_time_point > latest_valid_expiry_time_point) {
-        throw std::system_error(errc::common::invalid_argument,
-                                fmt::format("Document would expire sooner than requested, since the end of duration {}  is after {}",
-                                            expiry,
-                                            latest_valid_expiry_time_point));
-    }
+  auto expiry_time_point = std::chrono::system_clock::now() + expiry;
+  if (expiry_time_point > latest_valid_expiry_time_point) {
+    throw std::system_error(
+      errc::common::invalid_argument,
+      fmt::format(
+        "Document would expire sooner than requested, since the end of duration {}  is after {}",
+        expiry,
+        latest_valid_expiry_time_point));
+  }
 
-    auto seconds = std::chrono::duration_cast<std::chrono::seconds>(expiry_time_point.time_since_epoch());
-    return static_cast<std::uint32_t>(seconds.count());
+  auto seconds =
+    std::chrono::duration_cast<std::chrono::seconds>(expiry_time_point.time_since_epoch());
+  return static_cast<std::uint32_t>(seconds.count());
 }
 
-std::uint32_t
-expiry_absolute(std::chrono::system_clock::time_point expiry)
+auto
+expiry_absolute(std::chrono::system_clock::time_point expiry) -> std::uint32_t
 {
-    // Basic sanity check, prevent instant from being interpreted as a relative duration.
-    // Allow EPOCH (zero instant) because that is how "get with expiry" represents "no expiry"
-    if (expiry < earliest_valid_expiry_time_point && expiry != std::chrono::system_clock::time_point::min()) {
-        throw std::system_error(errc::common::invalid_argument,
-                                fmt::format("Expiry time_point must be zero (for no expiry) or later than {}, but got {}",
-                                            earliest_valid_expiry_time_point,
-                                            expiry));
-    }
+  // Basic sanity check, prevent instant from being interpreted as a relative duration.
+  // Allow EPOCH (zero instant) because that is how "get with expiry" represents "no expiry"
+  if (expiry < earliest_valid_expiry_time_point &&
+      expiry != std::chrono::system_clock::time_point::min()) {
+    throw std::system_error(
+      errc::common::invalid_argument,
+      fmt::format("Expiry time_point must be zero (for no expiry) or later than {}, but got {}",
+                  earliest_valid_expiry_time_point,
+                  expiry));
+  }
 
-    if (expiry > latest_valid_expiry_time_point) {
-        // Anything after this would roll over when converted to an unsigned 32-bit value
-        // and cause the document to expire sooner than expected.
-        throw std::system_error(errc::common::invalid_argument,
-                                fmt::format("Expiry instant must be no later than {}, but got {}", latest_valid_expiry_time_point, expiry));
-    }
-    auto seconds = std::chrono::duration_cast<std::chrono::seconds>(expiry.time_since_epoch());
-    return static_cast<std::uint32_t>(seconds.count());
+  if (expiry > latest_valid_expiry_time_point) {
+    // Anything after this would roll over when converted to an unsigned 32-bit value
+    // and cause the document to expire sooner than expected.
+    throw std::system_error(errc::common::invalid_argument,
+                            fmt::format("Expiry instant must be no later than {}, but got {}",
+                                        latest_valid_expiry_time_point,
+                                        expiry));
+  }
+  auto seconds = std::chrono::duration_cast<std::chrono::seconds>(expiry.time_since_epoch());
+  return static_cast<std::uint32_t>(seconds.count());
 }
 } // namespace couchbase::core::impl

package/deps/couchbase-cxx-client/core/impl/fail_fast_retry_strategy.cxx

@@ -22,20 +22,21 @@
 namespace couchbase
 {
 auto
-fail_fast_retry_strategy::retry_after(const retry_request& /* request */, retry_reason /* reason */) -> retry_action
+fail_fast_retry_strategy::retry_after(const retry_request& /* request */,
+                                      retry_reason /* reason */) -> retry_action
 {
-    return retry_action::do_not_retry();
+  return retry_action::do_not_retry();
 }
 
 auto
 fail_fast_retry_strategy::to_string() const -> std::string
 {
-    return fmt::format(R"(#<fail_fast_retry_strategy:{}>)", static_cast<const void*>(this));
+  return fmt::format(R"(#<fail_fast_retry_strategy:{}>)", static_cast<const void*>(this));
 }
 
 auto
 make_fail_fast_retry_strategy() -> std::shared_ptr<fail_fast_retry_strategy>
 {
-    return std::make_shared<fail_fast_retry_strategy>();
+  return std::make_shared<fail_fast_retry_strategy>();
 }
 } // namespace couchbase

package/deps/couchbase-cxx-client/core/impl/field_level_encryption_error_category.cxx

@@ -23,41 +23,43 @@ namespace couchbase::core::impl
 {
 
 struct field_level_encryption_error_category : std::error_category {
-    [[nodiscard]] const char* name() const noexcept override
-    {
-        return "couchbase.field_level_encryption";
-    }
+  [[nodiscard]] auto name() const noexcept -> const char* override
+  {
+    return "couchbase.field_level_encryption";
+  }
 
-    [[nodiscard]] std::string message(int ev) const noexcept override
-    {
-        switch (static_cast<errc::field_level_encryption>(ev)) {
-            case errc::field_level_encryption::generic_cryptography_failure:
-                return "generic_cryptography_failure (700)";
-            case errc::field_level_encryption::encryption_failure:
-                return "encryption_failure (701)";
-            case errc::field_level_encryption::decryption_failure:
-                return "decryption_failure (702)";
-            case errc::field_level_encryption::crypto_key_not_found:
-                return "crypto_key_not_found (703)";
-            case errc::field_level_encryption::invalid_crypto_key:
-                return "invalid_crypto_key (704)";
-            case errc::field_level_encryption::decrypter_not_found:
-                return "decrypter_not_found (705)";
-            case errc::field_level_encryption::encrypter_not_found:
-                return "encrypter_not_found (706)";
-            case errc::field_level_encryption::invalid_ciphertext:
-                return "invalid_ciphertext (707)";
-        }
-        return "FIXME: unknown error code (recompile with newer library): couchbase.field_level_encryption." + std::to_string(ev);
+  [[nodiscard]] auto message(int ev) const noexcept -> std::string override
+  {
+    switch (static_cast<errc::field_level_encryption>(ev)) {
+      case errc::field_level_encryption::generic_cryptography_failure:
+        return "generic_cryptography_failure (700)";
+      case errc::field_level_encryption::encryption_failure:
+        return "encryption_failure (701)";
+      case errc::field_level_encryption::decryption_failure:
+        return "decryption_failure (702)";
+      case errc::field_level_encryption::crypto_key_not_found:
+        return "crypto_key_not_found (703)";
+      case errc::field_level_encryption::invalid_crypto_key:
+        return "invalid_crypto_key (704)";
+      case errc::field_level_encryption::decrypter_not_found:
+        return "decrypter_not_found (705)";
+      case errc::field_level_encryption::encrypter_not_found:
+        return "encrypter_not_found (706)";
+      case errc::field_level_encryption::invalid_ciphertext:
+        return "invalid_ciphertext (707)";
     }
+    return "FIXME: unknown error code (recompile with newer library): "
+           "couchbase.field_level_encryption." +
+           std::to_string(ev);
+  }
 };
 
 const inline static field_level_encryption_error_category category_instance;
 
-const std::error_category&
-field_level_encryption_category() noexcept
+auto
+field_level_encryption_category() noexcept -> const std::error_category&
 {
-    return category_instance;
+  return category_instance;
 }
 
 } // namespace couchbase::core::impl

package/deps/couchbase-cxx-client/core/impl/geo_bounding_box_query.cxx

@@ -24,23 +24,23 @@ namespace couchbase
 auto
 geo_bounding_box_query::encode() const -> encoded_search_query
 {
-    encoded_search_query built;
-    built.query = tao::json::empty_object;
-    if (boost_) {
-        built.query["boost"] = boost_.value();
-    }
-    if (field_) {
-        built.query["field"] = field_.value();
-    }
-    built.query["top_left"] = {
-        { "lat", top_left_.latitude },
-        { "lon", top_left_.longitude },
-    };
-    built.query["bottom_right"] = {
-        { "lat", bottom_right_.latitude },
-        { "lon", bottom_right_.longitude },
-    };
+  encoded_search_query built;
+  built.query = tao::json::empty_object;
+  if (boost_) {
+    built.query["boost"] = boost_.value();
+  }
+  if (field_) {
+    built.query["field"] = field_.value();
+  }
+  built.query["top_left"] = {
+    { "lat", top_left_.latitude },
+    { "lon", top_left_.longitude },
+  };
+  built.query["bottom_right"] = {
+    { "lat", bottom_right_.latitude },
+    { "lon", bottom_right_.longitude },
+  };
 
-    return built;
+  return built;
 }
 } // namespace couchbase

package/deps/couchbase-cxx-client/core/impl/geo_distance_query.cxx

@@ -24,20 +24,20 @@ namespace couchbase
 auto
 geo_distance_query::encode() const -> encoded_search_query
 {
-    encoded_search_query built;
-    built.query = tao::json::empty_object;
-    if (boost_) {
-        built.query["boost"] = boost_.value();
-    }
-    if (field_) {
-        built.query["field"] = field_.value();
-    }
-    built.query["distance"] = distance_;
-    built.query["location"] = {
-        { "lat", location_.latitude },
-        { "lon", location_.longitude },
-    };
+  encoded_search_query built;
+  built.query = tao::json::empty_object;
+  if (boost_) {
+    built.query["boost"] = boost_.value();
+  }
+  if (field_) {
+    built.query["field"] = field_.value();
+  }
+  built.query["distance"] = distance_;
+  built.query["location"] = {
+    { "lat", location_.latitude },
+    { "lon", location_.longitude },
+  };
 
-    return built;
+  return built;
 }
 } // namespace couchbase

package/deps/couchbase-cxx-client/core/impl/geo_polygon_query.cxx

@@ -24,23 +24,23 @@ namespace couchbase
 auto
 geo_polygon_query::encode() const -> encoded_search_query
 {
-    encoded_search_query built;
-    built.query = tao::json::empty_object;
-    if (boost_) {
-        built.query["boost"] = boost_.value();
-    }
-    if (field_) {
-        built.query["field"] = field_.value();
-    }
-    tao::json::value polygon_points = tao::json::empty_array;
-    for (const auto& point : polygon_points_) {
-        polygon_points.emplace_back(tao::json::value{
-          { "lat", point.latitude },
-          { "lon", point.longitude },
-        });
-    }
-    built.query["polygon_points"] = polygon_points;
+  encoded_search_query built;
+  built.query = tao::json::empty_object;
+  if (boost_) {
+    built.query["boost"] = boost_.value();
+  }
+  if (field_) {
+    built.query["field"] = field_.value();
+  }
+  tao::json::value polygon_points = tao::json::empty_array;
+  for (const auto& point : polygon_points_) {
+    polygon_points.emplace_back(tao::json::value{
+      { "lat", point.latitude },
+      { "lon", point.longitude },
+    });
+  }
+  built.query["polygon_points"] = polygon_points;
 
-    return built;
+  return built;
 }
 } // namespace couchbase

package/deps/couchbase-cxx-client/core/impl/get_all_replicas.hxx

@@ -40,33 +40,37 @@ namespace couchbase::core::impl
  */
 class get_all_replicas_request
 {
-  public:
-    explicit get_all_replicas_request(std::string bucket_name,
-                                      std::string scope_name,
-                                      std::string collection_name,
-                                      std::string document_key,
-                                      std::optional<std::chrono::milliseconds> timeout)
-      : id_{ std::move(bucket_name), std::move(scope_name), std::move(collection_name), std::move(document_key) }
-      , timeout_{ timeout }
-    {
-    }
+public:
+  explicit get_all_replicas_request(std::string bucket_name,
+                                    std::string scope_name,
+                                    std::string collection_name,
+                                    std::string document_key,
+                                    std::optional<std::chrono::milliseconds> timeout)
+    : id_{ std::move(bucket_name),
+           std::move(scope_name),
+           std::move(collection_name),
+           std::move(document_key) }
+    , timeout_{ timeout }
+  {
+  }
 
-    [[nodiscard]] const auto& id() const
-    {
-        return id_;
-    }
+  [[nodiscard]] auto id() const -> const auto&
+  {
+    return id_;
+  }
 
-    [[nodiscard]] const auto& timeout() const
-    {
-        return timeout_;
-    }
+  [[nodiscard]] auto timeout() const -> const auto&
+  {
+    return timeout_;
+  }
 
-  private:
-    core::document_id id_;
-    std::optional<std::chrono::milliseconds> timeout_{};
+private:
+  core::document_id id_;
+  std::optional<std::chrono::milliseconds> timeout_{};
 };
 
-using movable_get_all_replicas_handler = utils::movable_function<void(couchbase::key_value_error_context, get_all_replicas_result)>;
+using movable_get_all_replicas_handler =
+  utils::movable_function<void(error, get_all_replicas_result)>;
 
 void
 initiate_get_all_replicas_operation(std::shared_ptr<cluster> core,

package/deps/couchbase-cxx-client/core/impl/get_any_replica.hxx

@@ -20,7 +20,6 @@
 #include <couchbase/get_any_replica_options.hxx>
 
 #include "core/document_id.hxx"
-#include "core/error_context/key_value.hxx"
 #include "core/utils/movable_function.hxx"
 
 namespace couchbase::core::impl
@@ -37,33 +36,36 @@ namespace couchbase::core::impl
  */
 class get_any_replica_request
 {
-  public:
-    explicit get_any_replica_request(std::string bucket_name,
-                                     std::string scope_name,
-                                     std::string collection_name,
-                                     std::string document_key,
-                                     std::optional<std::chrono::milliseconds> timeout)
-      : id_{ std::move(bucket_name), std::move(scope_name), std::move(collection_name), std::move(document_key) }
-      , timeout_{ timeout }
-    {
-    }
+public:
+  explicit get_any_replica_request(std::string bucket_name,
+                                   std::string scope_name,
+                                   std::string collection_name,
+                                   std::string document_key,
+                                   std::optional<std::chrono::milliseconds> timeout)
+    : id_{ std::move(bucket_name),
+           std::move(scope_name),
+           std::move(collection_name),
+           std::move(document_key) }
+    , timeout_{ timeout }
+  {
+  }
 
-    [[nodiscard]] const auto& id() const
-    {
-        return id_;
-    }
+  [[nodiscard]] auto id() const -> const auto&
+  {
+    return id_;
+  }
 
-    [[nodiscard]] const auto& timeout() const
-    {
-        return timeout_;
-    }
+  [[nodiscard]] auto timeout() const -> const auto&
+  {
+    return timeout_;
+  }
 
-  private:
-    core::document_id id_;
-    std::optional<std::chrono::milliseconds> timeout_{};
+private:
+  core::document_id id_;
+  std::optional<std::chrono::milliseconds> timeout_{};
 };
 
-using movable_get_any_replica_handler = utils::movable_function<void(couchbase::key_value_error_context, get_replica_result)>;
+using movable_get_any_replica_handler = utils::movable_function<void(error, get_replica_result)>;
 
 void
 initiate_get_any_replica_operation(std::shared_ptr<cluster> core,

package/deps/couchbase-cxx-client/core/impl/get_replica.cxx

@@ -21,24 +21,27 @@
 
 namespace couchbase::core::impl
 {
-std::error_code
-get_replica_request::encode_to(get_replica_request::encoded_request_type& encoded, core::mcbp_context&& /* context */)
+auto
+get_replica_request::encode_to(get_replica_request::encoded_request_type& encoded,
+                               core::mcbp_context&& /* context */) -> std::error_code
 {
-    encoded.opaque(opaque);
-    encoded.partition(partition);
-    encoded.body().id(id);
-    return {};
+  encoded.opaque(opaque);
+  encoded.partition(partition);
+  encoded.body().id(id);
+  return {};
 }
 
-get_replica_response
-get_replica_request::make_response(key_value_error_context&& ctx, const encoded_response_type& encoded) const
+auto
+get_replica_request::make_response(key_value_error_context&& ctx,
+                                   const encoded_response_type& encoded) const
+  -> get_replica_response
 {
-    get_replica_response response{ std::move(ctx) };
-    if (!response.ctx.ec()) {
-        response.value = encoded.body().value();
-        response.cas = encoded.cas();
-        response.flags = encoded.body().flags();
-    }
-    return response;
+  get_replica_response response{ std::move(ctx) };
+  if (!response.ctx.ec()) {
+    response.value = encoded.body().value();
+    response.cas = encoded.cas();
+    response.flags = encoded.body().flags();
+  }
+  return response;
 }
 } // namespace couchbase::core::impl

package/deps/couchbase-cxx-client/core/impl/get_replica.hxx

@@ -17,7 +17,7 @@
 
 #pragma once
 
-#include <couchbase/key_value_error_context.hxx>
+#include "core/error_context/key_value_error_context.hxx"
 
 #include "core/io/mcbp_context.hxx"
 #include "core/io/retry_context.hxx"
@@ -28,25 +28,30 @@
 namespace couchbase::core::impl
 {
 struct get_replica_response {
-    key_value_error_context ctx{};
-    std::vector<std::byte> value{};
-    couchbase::cas cas{};
-    std::uint32_t flags{};
+  key_value_error_context ctx{};
+  std::vector<std::byte> value{};
+  couchbase::cas cas{};
+  std::uint32_t flags{};
 };
 
 struct get_replica_request {
-    using response_type = get_replica_response;
-    using encoded_request_type = core::protocol::client_request<core::protocol::get_replica_request_body>;
-    using encoded_response_type = core::protocol::client_response<core::protocol::get_replica_response_body>;
-
-    core::document_id id;
-    std::optional<std::chrono::milliseconds> timeout{};
-    std::uint16_t partition{};
-    std::uint32_t opaque{};
-    io::retry_context<true> retries{};
-
-    [[nodiscard]] std::error_code encode_to(encoded_request_type& encoded, core::mcbp_context&& context);
-
-    [[nodiscard]] get_replica_response make_response(key_value_error_context&& ctx, const encoded_response_type& encoded) const;
+  using response_type = get_replica_response;
+  using encoded_request_type =
+    core::protocol::client_request<core::protocol::get_replica_request_body>;
+  using encoded_response_type =
+    core::protocol::client_response<core::protocol::get_replica_response_body>;
+
+  core::document_id id;
+  std::optional<std::chrono::milliseconds> timeout{};
+  std::uint16_t partition{};
+  std::uint32_t opaque{};
+  io::retry_context<true> retries{};
+
+  [[nodiscard]] auto encode_to(encoded_request_type& encoded,
+                               core::mcbp_context&& context) -> std::error_code;
+
+  [[nodiscard]] auto make_response(key_value_error_context&& ctx,
+                                   const encoded_response_type& encoded) const
+    -> get_replica_response;
 };
 } // namespace couchbase::core::impl