couchbase 4.2.8-dev.1 → 4.2.9

package/deps/couchbase-cxx-client/core/io/dns_config.hxx

@@ -20,8 +20,6 @@
 #include "core/timeout_defaults.hxx"
 
 #include <cstdint>
-#include <filesystem>
-#include <fstream>
 #include <string>
 
 namespace couchbase::core::io::dns
@@ -32,31 +30,14 @@ class dns_config
     static constexpr auto default_nameserver = "8.8.8.8";
     static constexpr std::uint16_t default_port = 53;
 
-    dns_config() = default;
-
-    dns_config(const std::string& nameserver, std::uint16_t port, std::chrono::milliseconds timeout = timeout_defaults::dns_srv_timeout)
-      : nameserver_{ nameserver }
-      , port_{ port }
-      , timeout_{ timeout }
-    {
-    }
-
-    [[nodiscard]] std::uint16_t port() const
-    {
-        return port_;
-    }
-
-    [[nodiscard]] const std::string& nameserver() const
-    {
-        return nameserver_;
-    }
+    static const dns_config& system_config();
 
-    [[nodiscard]] std::chrono::milliseconds timeout() const
-    {
-        return timeout_;
-    }
+    dns_config() = default;
+    dns_config(std::string nameserver, std::uint16_t port, std::chrono::milliseconds timeout = timeout_defaults::dns_srv_timeout);
 
-    static const dns_config& system_config();
+    [[nodiscard]] std::uint16_t port() const;
+    [[nodiscard]] const std::string& nameserver() const;
+    [[nodiscard]] std::chrono::milliseconds timeout() const;
 
   private:
     std::string nameserver_{ default_nameserver };

package/deps/couchbase-cxx-client/core/io/http_session_manager.hxx

@@ -29,6 +29,8 @@
 
 #include <gsl/narrow>
 
+#include <chrono>
+#include <optional>
 #include <random>
 
 namespace couchbase::core::io
@@ -104,6 +106,7 @@ class http_session_manager
 
     template<typename Collector>
     void ping(std::set<service_type> services,
+              std::optional<std::chrono::milliseconds> timeout,
               std::shared_ptr<Collector> collector,
               const couchbase::core::cluster_credentials& credentials)
     {
@@ -153,6 +156,7 @@ class http_session_manager
                     }
                     operations::http_noop_request request{};
                     request.type = type;
+                    request.timeout = timeout;
                     auto cmd = std::make_shared<operations::http_command<operations::http_noop_request>>(
                       ctx_, request, tracer_, meter_, options_.default_timeout_for(request.type));
                     cmd->start([start = std::chrono::steady_clock::now(),
@@ -163,7 +167,11 @@ class http_session_manager
                         diag::ping_state state = diag::ping_state::ok;
                         std::optional<std::string> error{};
                         if (ec) {
-                            state = diag::ping_state::error;
+                            if (ec == errc::common::unambiguous_timeout || ec == errc::common::ambiguous_timeout) {
+                                state = diag::ping_state::timeout;
+                            } else {
+                                state = diag::ping_state::error;
+                            }
                             error.emplace(fmt::format("code={}, message={}, http_code={}", ec.value(), ec.message(), msg.status_code));
                         }
                         handler->report(diag::endpoint_ping_info{

package/deps/couchbase-cxx-client/core/io/mcbp_command.hxx

@@ -269,7 +269,7 @@ struct mcbp_command : public std::enable_shared_from_this<mcbp_command<Manager,
                                                                                                  : errc::common::ambiguous_timeout));
               }
               if (ec == errc::common::request_canceled) {
-                  if (reason == retry_reason::do_not_retry) {
+                  if (!self->request.retries.idempotent() && !allows_non_idempotent_retry(reason)) {
                       if (self->span_->uses_tags())
                           self->span_->add_tag(tracing::attributes::orphan, "canceled");
                       return self->invoke_handler(ec);

package/deps/couchbase-cxx-client/core/io/mcbp_message.hxx

@@ -46,9 +46,10 @@ struct binary_header {
 };
 
 struct mcbp_message {
-    binary_header header;
-    std::vector<std::byte> body;
+    binary_header header{};
+    std::vector<std::byte> body{};
 
+    mcbp_message() = default;
     mcbp_message(const mcbp_message& other) = delete;
     mcbp_message& operator=(const mcbp_message& other) = delete;
     mcbp_message(mcbp_message&& other) = default;

package/deps/couchbase-cxx-client/core/io/mcbp_session.cxx

@@ -51,6 +51,7 @@
 #include "streams.hxx"
 
 #include <couchbase/build_config.hxx>
+#include <couchbase/error_codes.hxx>
 #include <couchbase/fmt/retry_reason.hxx>
 
 #include <asio.hpp>
@@ -153,12 +154,12 @@ struct connection_endpoints {
     connection_endpoints(asio::ip::tcp::endpoint remote_endpoint, asio::ip::tcp::endpoint local_endpoint)
       : remote{ std::move(remote_endpoint) }
       , remote_address{ remote.address().to_string() }
-      , remote_address_with_port{ fmt::format(remote.protocol() == asio::ip::tcp::v6() ? "[{}]:{}" : "{}:{}",
-                                              remote_address,
-                                              remote.port()) }
+      , remote_address_with_port{ remote.protocol() == asio::ip::tcp::v6() ? fmt::format("[{}]:{}", remote_address, remote.port())
+                                                                           : fmt::format("{}:{}", remote_address, remote.port()) }
       , local{ std::move(local_endpoint) }
       , local_address{ local.address().to_string() }
-      , local_address_with_port{ fmt::format(local.protocol() == asio::ip::tcp::v6() ? "[{}]:{}" : "{}:{}", local_address, local.port()) }
+      , local_address_with_port{ local.protocol() == asio::ip::tcp::v6() ? fmt::format("[{}]:{}", local_address, local.port())
+                                                                         : fmt::format("{}:{}", local_address, local.port()) }
     {
     }
 
@@ -245,6 +246,7 @@ class mcbp_session_impl
             }
             if (session_->origin_.options().enable_clustermap_notification) {
                 hello_req.body().enable_clustermap_change_notification();
+                hello_req.body().enable_deduplicate_not_my_vbucket_clustermap();
             }
             if (session_->origin_.options().enable_compression) {
                 hello_req.body().enable_compression();
@@ -259,7 +261,7 @@ class mcbp_session_impl
             CB_LOG_DEBUG("{} user_agent={}, requested_features=[{}]",
                          session_->log_prefix_,
                          user_agent,
-                         utils::join_strings_fmt("{}", hello_req.body().features(), ", "));
+                         utils::join_strings_fmt(hello_req.body().features(), ", "));
             session_->write(hello_req.data());
 
             if (!session_->origin_.credentials().uses_certificate()) {
@@ -347,7 +349,7 @@ class mcbp_session_impl
                                 session_->supported_features_ = resp.body().supported_features();
                                 CB_LOG_DEBUG("{} supported_features=[{}]",
                                              session_->log_prefix_,
-                                             utils::join_strings_fmt("{}", session_->supported_features_, ", "));
+                                             utils::join_strings_fmt(session_->supported_features_, ", "));
                                 if (session_->origin_.credentials().uses_certificate()) {
                                     CB_LOG_DEBUG("{} skip SASL authentication, because TLS certificate was specified",
                                                  session_->log_prefix_);
@@ -664,7 +666,18 @@ class mcbp_session_impl
                     Expects(protocol::is_valid_server_request_opcode(msg.header.opcode));
                     switch (static_cast<protocol::server_opcode>(msg.header.opcode)) {
                         case protocol::server_opcode::cluster_map_change_notification: {
-                            protocol::server_request<protocol::cluster_map_change_notification_request_body> req(std::move(msg));
+                            protocol::cmd_info info{ session_->bootstrap_hostname_, session_->bootstrap_port_number_ };
+                            if (session_->origin_.options().dump_configuration) {
+                                std::string_view config_text{ reinterpret_cast<const char*>(msg.body.data()), msg.body.size() };
+                                CB_LOG_TRACE(
+                                  "{} configuration from cluster_map_change_notification request (size={}, endpoint=\"{}:{}\"), {}",
+                                  session_->log_prefix_,
+                                  config_text.size(),
+                                  info.endpoint_address,
+                                  info.endpoint_port,
+                                  config_text);
+                            }
+                            protocol::server_request<protocol::cluster_map_change_notification_request_body> req(std::move(msg), info);
                             std::optional<topology::configuration> config = req.body().config();
                             if (session_ && config.has_value()) {
                                 if ((!config->bucket.has_value() && req.body().bucket().empty()) ||
@@ -730,6 +743,7 @@ class mcbp_session_impl
       , bootstrap_deadline_(ctx_)
       , connection_deadline_(ctx_)
       , retry_backoff_(ctx_)
+      , ping_deadline_(ctx_)
       , origin_{ std::move(origin) }
       , bucket_name_{ std::move(bucket_name) }
       , supported_features_{ std::move(known_features) }
@@ -754,6 +768,7 @@ class mcbp_session_impl
       , bootstrap_deadline_(ctx_)
       , connection_deadline_(ctx_)
       , retry_backoff_(ctx_)
+      , ping_deadline_(ctx_)
       , origin_(std::move(origin))
       , bucket_name_(std::move(bucket_name))
       , supported_features_(std::move(known_features))
@@ -798,7 +813,7 @@ class mcbp_session_impl
                  bucket_name_ };
     }
 
-    void ping(std::shared_ptr<diag::ping_reporter> handler)
+    void ping(std::shared_ptr<diag::ping_reporter> handler, std::optional<std::chrono::milliseconds> timeout)
     {
         protocol::client_request<protocol::mcbp_noop_request_body> req;
         req.opaque(next_opaque());
@@ -812,7 +827,11 @@ class mcbp_session_impl
                                 diag::ping_state state = diag::ping_state::ok;
                                 std::optional<std::string> error{};
                                 if (ec) {
-                                    state = diag::ping_state::error;
+                                    if (ec == errc::common::unambiguous_timeout || ec == errc::common::ambiguous_timeout) {
+                                        state = diag::ping_state::timeout;
+                                    } else {
+                                        state = diag::ping_state::error;
+                                    }
                                     error.emplace(fmt::format("code={}, message={}, reason={}", ec.value(), ec.message(), reason));
                                 }
                                 handler->report({
@@ -826,6 +845,13 @@ class mcbp_session_impl
                                   error,
                                 });
                             });
+        ping_deadline_.expires_after(timeout.value_or(origin_.options().key_value_timeout));
+        ping_deadline_.async_wait([self = this->shared_from_this(), opaque = req.opaque()](std::error_code ec) {
+            if (ec == asio::error::operation_aborted) {
+                return;
+            }
+            static_cast<void>(self->cancel(opaque, errc::common::unambiguous_timeout, retry_reason::do_not_retry));
+        });
     }
 
     [[nodiscard]] mcbp_context context() const
@@ -850,8 +876,9 @@ class mcbp_session_impl
                 self->state_listener_->report_bootstrap_error(fmt::format("{}:{}", self->bootstrap_hostname_, self->bootstrap_port_), ec);
             }
             CB_LOG_WARNING("{} unable to bootstrap in time", self->log_prefix_);
-            auto h = std::move(self->bootstrap_callback_);
-            h(ec, {});
+            if (auto h = std::move(self->bootstrap_callback_); h) {
+                h(ec, {});
+            }
             self->stop(retry_reason::do_not_retry);
         });
         initiate_bootstrap();
@@ -926,6 +953,7 @@ class mcbp_session_impl
         bootstrap_deadline_.cancel();
         connection_deadline_.cancel();
         retry_backoff_.cancel();
+        ping_deadline_.cancel();
         resolver_.cancel();
         stream_->close([](std::error_code) {});
         if (auto h = std::move(bootstrap_handler_); h) {
@@ -1024,8 +1052,10 @@ class mcbp_session_impl
             }
         }
 
+        auto reason = status == static_cast<std::uint16_t>(key_value_status_code::not_my_vbucket) ? retry_reason::key_value_not_my_vbucket
+                                                                                                  : retry_reason::do_not_retry;
         if (fun) {
-            fun(protocol::map_status_code(opcode, status), retry_reason::do_not_retry, std::move(msg), decode_error_code(status));
+            fun(protocol::map_status_code(opcode, status), reason, std::move(msg), decode_error_code(status));
             return true;
         }
 
@@ -1043,11 +1073,8 @@ class mcbp_session_impl
             }
         }
         if (request) {
-            handler->handle_response(std::move(request),
-                                     protocol::map_status_code(opcode, status),
-                                     retry_reason::do_not_retry,
-                                     std::move(msg),
-                                     decode_error_code(status));
+            handler->handle_response(
+              std::move(request), protocol::map_status_code(opcode, status), reason, std::move(msg), decode_error_code(status));
             return true;
         }
         return false;
@@ -1245,11 +1272,12 @@ class mcbp_session_impl
                 }
             }
         }
+        config_.reset();
         config_.emplace(std::move(config));
         configured_ = true;
         for (const auto& listener : config_listeners_) {
-            asio::post(asio::bind_executor(
-              ctx_, [listener, config = config_.value()]() mutable { return listener->update_config(std::move(config)); }));
+            asio::post(
+              asio::bind_executor(ctx_, [listener, c = config_.value()]() mutable { return listener->update_config(std::move(c)); }));
         }
     }
 
@@ -1453,6 +1481,7 @@ class mcbp_session_impl
                                       bootstrap_hostname_,
                                       connection_endpoints_.remote_address,
                                       connection_endpoints_.remote.port());
+            parser_.reset();
             bootstrap_handler_ = std::make_shared<bootstrap_handler>(shared_from_this());
             connection_deadline_.cancel();
         }
@@ -1602,6 +1631,7 @@ class mcbp_session_impl
     asio::steady_timer bootstrap_deadline_;
     asio::steady_timer connection_deadline_;
     asio::steady_timer retry_backoff_;
+    asio::steady_timer ping_deadline_;
     couchbase::core::origin origin_;
     std::optional<std::string> bucket_name_;
     mcbp_parser parser_;
@@ -1827,9 +1857,9 @@ mcbp_session::supported_features() const
 }
 
 void
-mcbp_session::ping(std::shared_ptr<diag::ping_reporter> handler) const
+mcbp_session::ping(std::shared_ptr<diag::ping_reporter> handler, std::optional<std::chrono::milliseconds> timeout) const
 {
-    return impl_->ping(std::move(handler));
+    return impl_->ping(std::move(handler), std::move(timeout));
 }
 
 bool

package/deps/couchbase-cxx-client/core/io/mcbp_session.hxx

@@ -23,6 +23,7 @@
 #include "mcbp_context.hxx"
 #include "mcbp_message.hxx"
 
+#include <chrono>
 #include <cinttypes>
 #include <memory>
 #include <optional>
@@ -118,7 +119,7 @@ class mcbp_session
     [[nodiscard]] bool has_config() const;
     [[nodiscard]] diag::endpoint_diag_info diag_info() const;
     void on_configuration_update(std::shared_ptr<config_listener> handler);
-    void ping(std::shared_ptr<diag::ping_reporter> handler) const;
+    void ping(std::shared_ptr<diag::ping_reporter> handler, std::optional<std::chrono::milliseconds> = {}) const;
     [[nodiscard]] bool supports_gcccp() const;
     [[nodiscard]] std::optional<key_value_error_map_info> decode_error_code(std::uint16_t code);
     void handle_not_my_vbucket(const io::mcbp_message& msg) const;

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

@@ -178,16 +178,16 @@ log_protocol(const char* file, int line, const char* function, std::string_view
  * @param msg message to log
  * @param args the formatting arguments
  */
-template<typename String, typename... Args>
+template<typename... Args>
 inline void
-log(const char* file, int line, const char* function, level lvl, const String& msg, Args&&... args)
+log(const char* file, int line, const char* function, level lvl, fmt::format_string<Args...> msg, Args&&... args)
 {
     detail::log(file, line, function, lvl, fmt::format(msg, std::forward<Args>(args)...));
 }
 
-template<typename String, typename... Args>
+template<typename... Args>
 inline void
-log_protocol(const char* file, int line, const char* function, const String& msg, Args&&... args)
+log_protocol(const char* file, int line, const char* function, fmt::format_string<Args...> msg, Args&&... args)
 {
     detail::log_protocol(file, line, function, fmt::format(msg, std::forward<Args>(args)...));
 }

package/deps/couchbase-cxx-client/core/management/bucket_settings.hxx

@@ -116,7 +116,7 @@ struct bucket_settings {
     bucket_eviction_policy eviction_policy{ bucket_eviction_policy::unknown };
     bucket_conflict_resolution conflict_resolution_type{ bucket_conflict_resolution::unknown };
     std::optional<bool> history_retention_collection_default{};
-    std::optional<std::uint32_t> history_retention_bytes;
+    std::optional<std::uint32_t> history_retention_bytes{};
     std::optional<std::uint32_t> history_retention_duration{};
 
     /**

package/deps/couchbase-cxx-client/core/mcbp/packet.cxx

@@ -86,7 +86,7 @@ packet::debug_string() const
         }
     }
 
-    fmt::format_to(std::back_insert_iterator(out), "}");
+    fmt::format_to(std::back_insert_iterator(out), "}}");
     return { out.begin(), out.end() };
 }
 } // namespace couchbase::core::mcbp

package/deps/couchbase-cxx-client/core/mcbp/queue_callback.hxx

@@ -17,7 +17,7 @@
 
 #pragma once
 
-#include "../utils/movable_function.hxx"
+#include "core/utils/movable_function.hxx"
 
 #include <functional>
 #include <memory>

package/deps/couchbase-cxx-client/core/meta/features.hxx

@@ -73,3 +73,31 @@
 #define COUCHBASE_CXX_CLIENT_HAS_COLLECTION_QUERY_INDEX_MANAGEMENT 1
 
 #define COUCHBASE_CXX_CLIENT_TRANSACTIONS_EXT_PARALLEL_UNSTAGING
+
+/**
+ * core cluster implementation has been hidden and not accessible through the public API
+ */
+#define COUCHBASE_CXX_CLIENT_HAS_CORE_CLUSTER_HIDDEN 1
+
+/**
+ * expiration_time has been renamed to timeout in transactions_options and transactions_config
+ * kv_timeout removed from transactions_options and transactions_config
+ */
+#define COUCHBASE_CXX_CLIENT_TRANSACTIONS_OPTIONS_HAVE_TIMEOUT 1
+
+/**
+ * Search index management is accessible from the public API
+ * couchbase::cluster::search_indexes() support
+ */
+#define COUCHBASE_CXX_CLIENT_HAS_PUBLIC_SEARCH_INDEX_MANAGEMENT 1
+
+/**
+ * FTS is accessible from the public API
+ * couchbase::cluster::search_query() and couchbase::scope::search_query() support
+ */
+#define COUCHBASE_CXX_CLIENT_HAS_PUBLIC_SEARCH 1
+
+/**
+ * The document not locked (couchbase::errc::key_value::document_not_locked) error code is supported
+ */
+#define COUCHBASE_CXX_CLIENT_HAS_ERRC_DOCUMENT_NOT_LOCKED 1

package/deps/couchbase-cxx-client/core/operations/document_query.cxx

@@ -26,6 +26,7 @@
 #include <couchbase/error_codes.hxx>
 
 #include <gsl/assert>
+#include <regex>
 
 namespace couchbase::core::operations
 {
@@ -236,7 +237,9 @@ query_request::make_response(error_context::query&& ctx, const encoded_response_
                                response.ctx.client_context_id);
             }
         }
-        response.meta.status = payload.at("status").get_string();
+        if (const auto* s = payload.find("status"); s != nullptr) {
+            response.meta.status = payload.at("status").get_string();
+        }
         if (const auto* s = payload.find("signature"); s != nullptr) {
             response.meta.signature = couchbase::core::utils::json::generate(*s);
         }
@@ -342,6 +345,19 @@ query_request::make_response(error_context::query&& ctx, const encoded_response_
                     case 4090: /* IKey: "plan.build_prepared.name_not_in_encoded_plan" */
                         response.ctx.ec = errc::query::prepared_statement_failure;
                         break;
+                    case 4300: /* IKey: "plan.new_index_already_exists" */
+                        response.ctx.ec = errc::common::index_exists;
+                        break;
+                    case 5000: /* IKey: "Internal Error" */
+                        if (std::regex_search(response.ctx.first_error_message, std::regex{ ".*[iI]ndex .*already exist.*" })) {
+                            response.ctx.ec = errc::common::index_exists;
+                        } else if (response.ctx.first_error_message.find("Index does not exist") != std::string::npos ||
+                                   std::regex_search(response.ctx.first_error_message, std::regex{ ".*[iI]ndex .*[nN]ot [fF]ound.*" })) {
+                            response.ctx.ec = errc::common::index_not_found;
+                        } else if (response.ctx.first_error_message.find("Bucket Not Found") != std::string::npos) {
+                            response.ctx.ec = errc::common::bucket_not_found;
+                        }
+                        break;
                     case 12009: /* IKey: "datastore.couchbase.DML_error" */
                         if (response.ctx.first_error_message.find("CAS mismatch") != std::string::npos) {
                             response.ctx.ec = errc::common::cas_mismatch;

package/deps/couchbase-cxx-client/core/operations/document_query.hxx

@@ -34,7 +34,7 @@
 namespace couchbase::tracing
 {
 class request_span;
-}
+} // namespace couchbase::tracing
 
 namespace couchbase::core::operations
 {

package/deps/couchbase-cxx-client/core/operations/management/analytics_dataset_create.cxx

@@ -21,6 +21,8 @@
 #include "core/utils/name_codec.hxx"
 #include "error_utils.hxx"
 
+#include <fmt/core.h>
+
 namespace couchbase::core::operations::management
 {
 std::error_code

package/deps/couchbase-cxx-client/core/operations/management/analytics_dataset_drop.cxx

@@ -21,6 +21,8 @@
 #include "core/utils/name_codec.hxx"
 #include "error_utils.hxx"
 
+#include <fmt/core.h>
+
 namespace couchbase::core::operations::management
 {
 std::error_code

package/deps/couchbase-cxx-client/core/operations/management/analytics_dataverse_create.cxx

@@ -21,6 +21,8 @@
 #include "core/utils/name_codec.hxx"
 #include "error_utils.hxx"
 
+#include <fmt/core.h>
+
 namespace couchbase::core::operations::management
 {
 std::error_code

package/deps/couchbase-cxx-client/core/operations/management/analytics_dataverse_drop.cxx

@@ -21,6 +21,8 @@
 #include "core/utils/name_codec.hxx"
 #include "error_utils.hxx"
 
+#include <fmt/core.h>
+
 namespace couchbase::core::operations::management
 {
 std::error_code

package/deps/couchbase-cxx-client/core/operations/management/analytics_get_pending_mutations.cxx

@@ -20,6 +20,8 @@
 #include "core/utils/json.hxx"
 #include "error_utils.hxx"
 
+#include <fmt/core.h>
+
 namespace couchbase::core::operations::management
 {
 std::error_code

package/deps/couchbase-cxx-client/core/operations/management/analytics_index_drop.cxx

@@ -21,6 +21,8 @@
 #include "core/utils/name_codec.hxx"
 #include "error_utils.hxx"
 
+#include <fmt/core.h>
+
 namespace couchbase::core::operations::management
 {
 std::error_code

package/deps/couchbase-cxx-client/core/operations/management/analytics_link_connect.cxx

@@ -21,6 +21,8 @@
 #include "core/utils/name_codec.hxx"
 #include "error_utils.hxx"
 
+#include <fmt/core.h>
+
 namespace couchbase::core::operations::management
 {
 std::error_code

package/deps/couchbase-cxx-client/core/operations/management/analytics_link_disconnect.cxx

@@ -21,6 +21,8 @@
 #include "core/utils/name_codec.hxx"
 #include "error_utils.hxx"
 
+#include <fmt/core.h>
+
 namespace couchbase::core::operations::management
 {
 std::error_code

package/deps/couchbase-cxx-client/core/operations/management/analytics_link_drop.cxx

@@ -21,6 +21,8 @@
 #include "core/utils/url_codec.hxx"
 #include "error_utils.hxx"
 
+#include <fmt/core.h>
+
 namespace couchbase::core::operations::management
 {
 std::error_code

package/deps/couchbase-cxx-client/core/operations/management/analytics_link_get_all.cxx

@@ -24,6 +24,8 @@
 #include "core/utils/url_codec.hxx"
 #include "error_utils.hxx"
 
+#include <fmt/core.h>
+
 namespace couchbase::core::operations::management
 {
 std::error_code

package/deps/couchbase-cxx-client/core/operations/management/bucket_create.cxx

@@ -31,7 +31,7 @@ std::error_code
 bucket_create_request::encode_to(encoded_request_type& encoded, http_context& /* context */) const
 {
     encoded.method = "POST";
-    encoded.path = fmt::format("/pools/default/buckets");
+    encoded.path = "/pools/default/buckets";
 
     encoded.headers["content-type"] = "application/x-www-form-urlencoded";
     encoded.body.append(fmt::format("name={}", utils::string_codec::form_encode(bucket.name)));

package/deps/couchbase-cxx-client/core/operations/management/bucket_describe.cxx

@@ -20,6 +20,8 @@
 #include "core/utils/json.hxx"
 #include "error_utils.hxx"
 
+#include <fmt/core.h>
+
 namespace couchbase::core::operations::management
 {
 std::error_code

package/deps/couchbase-cxx-client/core/operations/management/bucket_drop.cxx

@@ -19,6 +19,8 @@
 
 #include "error_utils.hxx"
 
+#include <fmt/core.h>
+
 namespace couchbase::core::operations::management
 {
 std::error_code

package/deps/couchbase-cxx-client/core/operations/management/bucket_flush.cxx

@@ -19,6 +19,8 @@
 
 #include "error_utils.hxx"
 
+#include <fmt/core.h>
+
 namespace couchbase::core::operations::management
 {
 std::error_code

package/deps/couchbase-cxx-client/core/operations/management/bucket_get.cxx

@@ -21,6 +21,8 @@
 #include "core/utils/json.hxx"
 #include "error_utils.hxx"
 
+#include <fmt/core.h>
+
 namespace couchbase::core::operations::management
 {
 std::error_code

package/deps/couchbase-cxx-client/core/operations/management/change_password.cxx

@@ -19,13 +19,15 @@
 #include "core/utils/url_codec.hxx"
 #include "error_utils.hxx"
 
+#include <fmt/core.h>
+
 namespace couchbase::core::operations::management
 {
 std::error_code
 change_password_request::encode_to(encoded_request_type& encoded, http_context& /* context */) const
 {
     encoded.method = "POST";
-    encoded.path = fmt::format("/controller/changePassword");
+    encoded.path = "/controller/changePassword";
     encoded.headers["content-type"] = "application/x-www-form-urlencoded";
     encoded.body = fmt::format("password={}", utils::string_codec::form_encode(newPassword));
 

package/deps/couchbase-cxx-client/core/operations/management/collection_create.cxx

@@ -23,6 +23,8 @@
 
 #include <regex>
 
+#include <fmt/core.h>
+
 namespace couchbase::core::operations::management
 {
 std::error_code