couchbase 4.3.1 → 4.4.0

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

@@ -30,38 +30,38 @@ namespace couchbase::core
 static bool
 is_valid_collection_char(char ch)
 {
-    if (ch >= 'A' && ch <= 'Z') {
-        return true;
-    }
-    if (ch >= 'a' && ch <= 'z') {
-        return true;
-    }
-    if (ch >= '0' && ch <= '9') {
-        return true;
-    }
-    switch (ch) {
-        case '_':
-        case '-':
-        case '%':
-            return true;
-        default:
-            return false;
-    }
+  if (ch >= 'A' && ch <= 'Z') {
+    return true;
+  }
+  if (ch >= 'a' && ch <= 'z') {
+    return true;
+  }
+  if (ch >= '0' && ch <= '9') {
+    return true;
+  }
+  switch (ch) {
+    case '_':
+    case '-':
+    case '%':
+      return true;
+    default:
+      return false;
+  }
 }
 
 bool
 is_valid_collection_element(std::string_view element)
 {
-    if (element.empty() || element.size() > 251) {
-        return false;
-    }
-    return std::all_of(element.begin(), element.end(), is_valid_collection_char);
+  if (element.empty() || element.size() > 251) {
+    return false;
+  }
+  return std::all_of(element.begin(), element.end(), is_valid_collection_char);
 }
 
 [[nodiscard]] static std::string
 compile_collection_path(const std::string& scope, const std::string& collection)
 {
-    return fmt::format("{}.{}", scope, collection);
+  return fmt::format("{}.{}", scope, collection);
 }
 
 document_id::document_id(std::string bucket, std::string key)
@@ -71,32 +71,35 @@ document_id::document_id(std::string bucket, std::string key)
 {
 }
 
-document_id::document_id(std::string bucket, std::string scope, std::string collection, std::string key)
+document_id::document_id(std::string bucket,
+                         std::string scope,
+                         std::string collection,
+                         std::string key)
   : bucket_(std::move(bucket))
   , scope_(std::move(scope))
   , collection_(std::move(collection))
   , key_(std::move(key))
 {
-    collection_path_ = compile_collection_path(scope_, collection_);
+  collection_path_ = compile_collection_path(scope_, collection_);
 }
 
 bool
 document_id::has_default_collection() const
 {
-    return !use_collections_ || collection_path_ == "_default._default";
+  return !use_collections_ || collection_path_ == "_default._default";
 }
 
 std::vector<std::byte>
 make_protocol_key(const document_id& id)
 {
-    std::vector<std::byte> key{};
-    if (id.is_collection_resolved()) {
-        utils::unsigned_leb128<std::uint32_t> encoded(id.collection_uid());
-        key.reserve(encoded.size());
-        key.insert(key.end(), encoded.begin(), encoded.end());
-    }
-    key.reserve(key.size() + id.key().size());
-    couchbase::core::utils::to_binary(id.key(), std::back_insert_iterator(key));
-    return key;
+  std::vector<std::byte> key{};
+  if (id.is_collection_resolved()) {
+    utils::unsigned_leb128<std::uint32_t> encoded(id.collection_uid());
+    key.reserve(encoded.size());
+    key.insert(key.end(), encoded.begin(), encoded.end());
+  }
+  key.reserve(key.size() + id.key().size());
+  couchbase::core::utils::to_binary(id.key(), std::back_insert_iterator(key));
+  return key;
 }
 } // namespace couchbase::core

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

@@ -25,92 +25,93 @@
 namespace couchbase::core
 {
 struct document_id {
-    document_id() = default;
-    document_id(std::string bucket, std::string key);
-    document_id(std::string bucket, std::string scope, std::string collection, std::string key);
-
-    [[nodiscard]] const std::string& bucket() const
-    {
-        return bucket_;
-    }
-
-    [[nodiscard]] const std::string& scope() const
-    {
-        return scope_;
-    }
-
-    [[nodiscard]] const std::string& collection() const
-    {
-        return collection_;
-    }
-
-    [[nodiscard]] const std::string& collection_path() const
-    {
-        return collection_path_;
-    }
-
-    [[nodiscard]] const std::string& key() const
-    {
-        return key_;
-    }
-
-    [[nodiscard]] bool has_default_collection() const;
-
-    [[nodiscard]] bool is_collection_resolved() const
-    {
-        return collection_uid_.has_value();
-    }
-
-    [[nodiscard]] std::uint32_t collection_uid() const
-    {
-        return collection_uid_.value();
-    }
-
-    void collection_uid(std::uint32_t value)
-    {
-        collection_uid_ = value;
-    }
-
-    [[nodiscard]] bool use_collections() const
-    {
-        return use_collections_;
-    }
-
-    void use_collections(bool value)
-    {
-        use_collections_ = value;
-    }
-
-    [[nodiscard]] bool use_any_session() const
-    {
-        return use_any_session_;
-    }
-
-    void use_any_session(bool value)
-    {
-        use_any_session_ = value;
-    }
-
-    [[nodiscard]] std::size_t node_index() const
-    {
-        return node_index_;
-    }
-
-    void node_index(std::size_t index)
-    {
-        node_index_ = index;
-    }
-
-  private:
-    std::string bucket_{};
-    std::string scope_{};
-    std::string collection_{};
-    std::string key_{};
-    std::string collection_path_{};
-    std::optional<std::uint32_t> collection_uid_{}; // filled with resolved UID during request lifetime
-    bool use_collections_{ true };
-    bool use_any_session_{ false };
-    std::size_t node_index_{ 0 };
+  document_id() = default;
+  document_id(std::string bucket, std::string key);
+  document_id(std::string bucket, std::string scope, std::string collection, std::string key);
+
+  [[nodiscard]] const std::string& bucket() const
+  {
+    return bucket_;
+  }
+
+  [[nodiscard]] const std::string& scope() const
+  {
+    return scope_;
+  }
+
+  [[nodiscard]] const std::string& collection() const
+  {
+    return collection_;
+  }
+
+  [[nodiscard]] const std::string& collection_path() const
+  {
+    return collection_path_;
+  }
+
+  [[nodiscard]] const std::string& key() const
+  {
+    return key_;
+  }
+
+  [[nodiscard]] bool has_default_collection() const;
+
+  [[nodiscard]] bool is_collection_resolved() const
+  {
+    return collection_uid_.has_value();
+  }
+
+  [[nodiscard]] std::uint32_t collection_uid() const
+  {
+    return collection_uid_.value();
+  }
+
+  void collection_uid(std::uint32_t value)
+  {
+    collection_uid_ = value;
+  }
+
+  [[nodiscard]] bool use_collections() const
+  {
+    return use_collections_;
+  }
+
+  void use_collections(bool value)
+  {
+    use_collections_ = value;
+  }
+
+  [[nodiscard]] bool use_any_session() const
+  {
+    return use_any_session_;
+  }
+
+  void use_any_session(bool value)
+  {
+    use_any_session_ = value;
+  }
+
+  [[nodiscard]] std::size_t node_index() const
+  {
+    return node_index_;
+  }
+
+  void node_index(std::size_t index)
+  {
+    node_index_ = index;
+  }
+
+private:
+  std::string bucket_{};
+  std::string scope_{};
+  std::string collection_{};
+  std::string key_{};
+  std::string collection_path_{};
+  std::optional<std::uint32_t>
+    collection_uid_{}; // filled with resolved UID during request lifetime
+  bool use_collections_{ true };
+  bool use_any_session_{ false };
+  std::size_t node_index_{ 0 };
 };
 
 [[nodiscard]] std::vector<std::byte>

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

@@ -23,15 +23,15 @@
 
 template<>
 struct fmt::formatter<couchbase::core::document_id> {
-    template<typename ParseContext>
-    constexpr auto parse(ParseContext& ctx)
-    {
-        return ctx.begin();
-    }
+  template<typename ParseContext>
+  constexpr auto parse(ParseContext& ctx)
+  {
+    return ctx.begin();
+  }
 
-    template<typename FormatContext>
-    auto format(const couchbase::core::document_id& id, FormatContext& ctx) const
-    {
-        return format_to(ctx.out(), "{}/{}/{}", id.bucket(), id.collection_path(), id.key());
-    }
+  template<typename FormatContext>
+  auto format(const couchbase::core::document_id& id, FormatContext& ctx) const
+  {
+    return format_to(ctx.out(), "{}/{}/{}", id.bucket(), id.collection_path(), id.key());
+  }
 };

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

@@ -37,74 +37,75 @@ class request_span;
 namespace couchbase::core
 {
 enum class key_state {
-    not_persisted = 0x00,
-    persisted = 0x01,
-    not_found = 0x80,
-    deleted = 0x81,
+  not_persisted = 0x00,
+  persisted = 0x01,
+  not_found = 0x80,
+  deleted = 0x81,
 };
 
 class observe_options
 {
-  public:
-    std::vector<std::byte> key{};
-    std::uint32_t replica_index{};
-    std::string collection_name{};
-    std::string scope_name{};
-    std::uint32_t collection_id{};
-
-    std::shared_ptr<couchbase::retry_strategy> retry_strategy{};
-    std::chrono::milliseconds timeout{};
-    std::shared_ptr<couchbase::tracing::request_span> parent_span{};
-
-    struct {
-        std::string user{};
-    } internal{};
+public:
+  std::vector<std::byte> key{};
+  std::uint32_t replica_index{};
+  std::string collection_name{};
+  std::string scope_name{};
+  std::uint32_t collection_id{};
+
+  std::shared_ptr<couchbase::retry_strategy> retry_strategy{};
+  std::chrono::milliseconds timeout{};
+  std::shared_ptr<couchbase::tracing::request_span> parent_span{};
+
+  struct {
+    std::string user{};
+  } internal{};
 };
 
 class observe_result
 {
-  public:
-    key_state state{};
-    couchbase::cas cas{};
+public:
+  key_state state{};
+  couchbase::cas cas{};
 
-    struct {
-        std::optional<resource_unit_result> resource_units{};
-    } internal{};
+  struct {
+    std::optional<resource_unit_result> resource_units{};
+  } internal{};
 };
 
 using observe_callback = utils::movable_function<void(observe_result result, std::error_code ec)>;
 
 class observe_seqno_options
 {
-  public:
-    std::uint16_t vbucket_id{};
-    std::uint64_t vbucket_uuid{};
-    std::uint32_t replica_index{};
-
-    std::shared_ptr<couchbase::retry_strategy> retry_strategy{};
-    std::chrono::milliseconds timeout{};
-    std::shared_ptr<couchbase::tracing::request_span> parent_span{};
-
-    struct {
-        std::string user{};
-    } internal{};
+public:
+  std::uint16_t vbucket_id{};
+  std::uint64_t vbucket_uuid{};
+  std::uint32_t replica_index{};
+
+  std::shared_ptr<couchbase::retry_strategy> retry_strategy{};
+  std::chrono::milliseconds timeout{};
+  std::shared_ptr<couchbase::tracing::request_span> parent_span{};
+
+  struct {
+    std::string user{};
+  } internal{};
 };
 
 class observe_seqno_result
 {
-  public:
-    bool did_failover{};
-    std::uint16_t vbucket_id{};
-    std::uint64_t vbucket_uuid{};
-    std::uint64_t persist_sequence_number{};
-    std::uint64_t current_sequence_number{};
-    std::uint64_t old_vbucket_uuid{};
-    std::uint64_t last_sequence_number{};
-
-    struct {
-        std::optional<resource_unit_result> resource_units{};
-    } internal{};
+public:
+  bool did_failover{};
+  std::uint16_t vbucket_id{};
+  std::uint64_t vbucket_uuid{};
+  std::uint64_t persist_sequence_number{};
+  std::uint64_t current_sequence_number{};
+  std::uint64_t old_vbucket_uuid{};
+  std::uint64_t last_sequence_number{};
+
+  struct {
+    std::optional<resource_unit_result> resource_units{};
+  } internal{};
 };
 
-using observe_seqno_callback = utils::movable_function<void(observe_seqno_result result, std::error_code ec)>;
+using observe_seqno_callback =
+  utils::movable_function<void(observe_seqno_result result, std::error_code ec)>;
 } // namespace couchbase::core

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

@@ -29,24 +29,24 @@ namespace couchbase::core::error_context
 {
 
 struct analytics {
-    std::error_code ec{};
-    std::uint64_t first_error_code{};
-    std::string first_error_message{};
-    std::string client_context_id{};
-    std::string statement{};
-    std::optional<std::string> parameters{};
-
-    std::string method{};
-    std::string path{};
-    std::uint32_t http_status{};
-    std::string http_body{};
-    std::string hostname{};
-    std::uint16_t port{};
-
-    std::optional<std::string> last_dispatched_to{};
-    std::optional<std::string> last_dispatched_from{};
-    std::size_t retry_attempts{ 0 };
-    std::set<retry_reason> retry_reasons{};
+  std::error_code ec{};
+  std::uint64_t first_error_code{};
+  std::string first_error_message{};
+  std::string client_context_id{};
+  std::string statement{};
+  std::optional<std::string> parameters{};
+
+  std::string method{};
+  std::string path{};
+  std::uint32_t http_status{};
+  std::string http_body{};
+  std::string hostname{};
+  std::uint16_t port{};
+
+  std::optional<std::string> last_dispatched_to{};
+  std::optional<std::string> last_dispatched_from{};
+  std::size_t retry_attempts{ 0 };
+  std::set<retry_reason> retry_reasons{};
 };
 
 } // namespace couchbase::core::error_context

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

@@ -0,0 +1,115 @@
+/* -*- Mode: C++; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */
+/*
+ *   Copyright 2024. Couchbase, Inc.
+ *
+ *   Licensed under the Apache License, Version 2.0 (the "License");
+ *   you may not use this file except in compliance with the License.
+ *   You may obtain a copy of the License at
+ *
+ *       http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *   Unless required by applicable law or agreed to in writing, software
+ *   distributed under the License is distributed on an "AS IS" BASIS,
+ *   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *   See the License for the specific language governing permissions and
+ *   limitations under the License.
+ */
+
+#pragma once
+
+#include <core/error_context/analytics.hxx>
+#include <core/impl/retry_reason.hxx>
+
+#include <couchbase/error_codes.hxx>
+#include <couchbase/fmt/retry_reason.hxx>
+
+#include <tao/json/forward.hpp>
+#include <tao/json/value.hpp>
+
+namespace tao::json
+{
+template<>
+struct traits<couchbase::core::error_context::analytics> {
+  template<template<typename...> class Traits>
+  static void assign(tao::json::basic_value<Traits>& v,
+                     const couchbase::core::error_context::analytics& ctx)
+  {
+    v["retry_attempts"] = ctx.retry_attempts;
+    v["client_context_id"] = ctx.client_context_id;
+    v["statement"] = ctx.statement;
+    v["method"] = ctx.method;
+    v["path"] = ctx.path;
+    v["http_status"] = ctx.http_status;
+    v["http_body"] = ctx.http_body;
+    v["hostname"] = ctx.hostname;
+    v["port"] = ctx.port;
+
+    if (const auto& val = ctx.parameters; val.has_value()) {
+      v["parameters"] = val.value();
+    }
+    if (ctx.first_error_code > 0) {
+      v["first_error_code"] = ctx.first_error_code;
+    }
+    if (!ctx.first_error_message.empty()) {
+      v["first_error_message"] = ctx.first_error_message;
+    }
+    if (const auto& reasons = ctx.retry_reasons; !reasons.empty()) {
+      tao::json::value reasons_json = tao::json::empty_array;
+      for (const auto& reason : reasons) {
+        reasons_json.emplace_back(fmt::format("{}", reason));
+      }
+      v["retry_reasons"] = reasons_json;
+    }
+    if (const auto& val = ctx.last_dispatched_from; val.has_value()) {
+      v["last_dispatched_from"] = val.value();
+    }
+    if (const auto& val = ctx.last_dispatched_to; val.has_value()) {
+      v["last_dispatched_to"] = val.value();
+    }
+  }
+
+  template<template<typename...> class Traits>
+  static auto as(const tao::json::basic_value<Traits>& v)
+    -> couchbase::core::error_context::analytics
+  {
+    couchbase::core::error_context::analytics ctx;
+    ctx.retry_attempts = v.at("retry_attempts").get_unsigned();
+    ctx.client_context_id = v.at("client_context_id").get_string();
+    ctx.statement = v.at("statement").get_string();
+    ctx.method = v.at("method").get_string();
+    ctx.path = v.at("path").get_string();
+    ctx.http_status = static_cast<uint32_t>(v.at("http_status").get_unsigned());
+    ctx.http_body = v.at("http_body").get_string();
+    ctx.hostname = v.at("hostname").get_string();
+    ctx.port = static_cast<uint16_t>(v.at("port").get_unsigned());
+    if (const auto& parameters = v.find("parameters");
+        parameters != nullptr && parameters->is_string()) {
+      ctx.parameters = parameters->get_string();
+    }
+    if (const auto& first_error_code = v.find("first_error_code");
+        first_error_code != nullptr && first_error_code->is_integer()) {
+      ctx.first_error_code = first_error_code->get_unsigned();
+    }
+    if (const auto& first_error_message = v.find("first_error_message");
+        first_error_message != nullptr && first_error_message->is_string()) {
+      ctx.first_error_message = first_error_message->get_string();
+    }
+    if (const auto& retry_reasons = v.find("retry_reasons");
+        retry_reasons != nullptr && retry_reasons->is_array()) {
+      for (const auto& retry_reason : retry_reasons->get_array()) {
+        ctx.retry_reasons.insert(
+          couchbase::core::impl::retry_reason_to_enum(retry_reason.get_string()));
+      }
+    }
+    if (const auto& last_dispatched_from = v.find("last_dispatched_from");
+        last_dispatched_from != nullptr && last_dispatched_from->is_string()) {
+      ctx.last_dispatched_from = last_dispatched_from->get_string();
+    }
+    if (const auto& last_dispatched_to = v.find("last_dispatched_to");
+        last_dispatched_to != nullptr && last_dispatched_to->is_string()) {
+      ctx.last_dispatched_to = last_dispatched_to->get_string();
+    }
+    return ctx;
+  }
+};
+} // namespace tao::json