couchbase 4.2.8 → 4.2.10

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_);
@@ -540,17 +542,11 @@ class mcbp_session_impl
     {
       private:
         std::shared_ptr<mcbp_session_impl> session_;
-        asio::steady_timer heartbeat_timer_;
-        std::chrono::milliseconds heartbeat_interval_;
         std::atomic_bool stopped_{ false };
 
       public:
         explicit message_handler(std::shared_ptr<mcbp_session_impl> session)
           : session_(std::move(session))
-          , heartbeat_timer_(session_->ctx_)
-          , heartbeat_interval_{ session_->origin_.options().config_poll_floor > session_->origin_.options().config_poll_interval
-                                   ? session_->origin_.options().config_poll_floor
-                                   : session_->origin_.options().config_poll_interval }
         {
         }
 
@@ -561,16 +557,10 @@ class mcbp_session_impl
 
         void start()
         {
-            if (session_->supports_gcccp_) {
-                fetch_config({});
-            }
         }
 
         void stop()
         {
-            if (bool expected_state{ false }; stopped_.compare_exchange_strong(expected_state, true)) {
-                heartbeat_timer_.cancel();
-            }
         }
 
         void handle(mcbp_message&& msg)
@@ -664,7 +654,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()) ||
@@ -696,23 +697,6 @@ class mcbp_session_impl
                     break;
             }
         }
-
-        void fetch_config(std::error_code ec)
-        {
-            if (ec == asio::error::operation_aborted || stopped_ || !session_) {
-                return;
-            }
-            protocol::client_request<protocol::get_cluster_config_request_body> req;
-            req.opaque(session_->next_opaque());
-            session_->write_and_flush(req.data());
-            heartbeat_timer_.expires_after(heartbeat_interval_);
-            heartbeat_timer_.async_wait([self = shared_from_this()](std::error_code e) {
-                if (e == asio::error::operation_aborted) {
-                    return;
-                }
-                self->fetch_config(e);
-            });
-        }
     };
 
   public:
@@ -730,6 +714,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 +739,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 +784,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 +798,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 +816,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 +847,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 +924,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 +1023,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 +1044,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 +1243,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)); }));
         }
     }
 
@@ -1372,6 +1371,7 @@ class mcbp_session_impl
             return initiate_bootstrap();
         }
         endpoints_ = endpoints;
+        CB_LOG_TRACE("{} resolved \"{}:{}\" to {} endpoint(s)", log_prefix_, bootstrap_hostname_, bootstrap_port_, endpoints_.size());
         do_connect(endpoints_.begin());
         connection_deadline_.expires_after(origin_.options().resolve_timeout);
         connection_deadline_.async_wait([self = shared_from_this()](const auto timer_ec) {
@@ -1391,19 +1391,33 @@ class mcbp_session_impl
         if (it != endpoints_.end()) {
             auto hostname = it->endpoint().address().to_string();
             auto port = it->endpoint().port();
-            CB_LOG_DEBUG("{} connecting to {}:{}, timeout={}ms", log_prefix_, hostname, port, origin_.options().connect_timeout.count());
+            CB_LOG_DEBUG("{} connecting to {}:{} (\"{}:{}\"), timeout={}ms",
+                         log_prefix_,
+                         hostname,
+                         port,
+                         bootstrap_hostname_,
+                         bootstrap_port_,
+                         origin_.options().connect_timeout.count());
             connection_deadline_.expires_after(origin_.options().connect_timeout);
             connection_deadline_.async_wait([self = shared_from_this(), hostname, port](const auto timer_ec) {
                 if (timer_ec == asio::error::operation_aborted || self->stopped_) {
                     return;
                 }
-                CB_LOG_DEBUG("{} unable to connect to {}:{} in time, reconnecting", self->log_prefix_, hostname, port);
+                CB_LOG_DEBUG("{} unable to connect to {}:{} (\"{}:{}\") in time, reconnecting",
+                             self->log_prefix_,
+                             hostname,
+                             port,
+                             self->bootstrap_hostname_,
+                             self->bootstrap_port_);
                 return self->stream_->close([self](std::error_code) { self->initiate_bootstrap(); });
             });
             stream_->async_connect(it->endpoint(),
                                    std::bind(&mcbp_session_impl::on_connect, shared_from_this(), std::placeholders::_1, it));
         } else {
-            CB_LOG_ERROR("{} no more endpoints left to connect, will try another address", log_prefix_);
+            CB_LOG_ERROR("{} no more endpoints left to connect to \"{}:{}\", will try another address",
+                         log_prefix_,
+                         bootstrap_hostname_,
+                         bootstrap_port_);
             if (state_listener_) {
                 state_listener_->report_bootstrap_error(fmt::format("{}:{}", bootstrap_hostname_, bootstrap_port_),
                                                         errc::network::no_endpoints_left);
@@ -1453,6 +1467,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 +1617,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 +1843,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
@@ -1862,4 +1878,10 @@ mcbp_session::write_and_subscribe(std::shared_ptr<mcbp::queue_request> request,
     return impl_->write_and_subscribe(std::move(request), std::move(handler));
 }
 
+void
+mcbp_session::write_and_flush(std::vector<std::byte>&& buffer)
+{
+    return impl_->write_and_flush(std::move(buffer));
+}
+
 } // namespace couchbase::core::io

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>
@@ -108,6 +109,7 @@ class mcbp_session
     [[nodiscard]] const std::string& bootstrap_hostname() const;
     [[nodiscard]] const std::string& bootstrap_port() const;
     [[nodiscard]] std::uint16_t bootstrap_port_number() const;
+    void write_and_flush(std::vector<std::byte>&& buffer);
     void write_and_subscribe(std::shared_ptr<mcbp::queue_request>, std::shared_ptr<response_handler> handler);
     void write_and_subscribe(std::uint32_t opaque, std::vector<std::byte>&& data, command_handler&& handler);
     void bootstrap(utils::movable_function<void(std::error_code, topology::configuration)>&& handler,
@@ -118,7 +120,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.cxx

@@ -30,7 +30,7 @@ static const std::string protocol_logger_name{ "couchbase_cxx_client_protocol_lo
  * This pattern is duplicated for some test cases. If you need to update it,
  * please also update in all relevant places.
  */
-static const std::string log_pattern{ "[%Y-%m-%d %T.%e] [%P,%t] [%^%l%$] %oms, %v" };
+static const std::string log_pattern{ "[%Y-%m-%d %T.%e] %4oms [%^%4!l%$] [%P,%t] %v" };
 
 /**
  * Instances of spdlog (async) file logger.

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,41 @@
 #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
+
+/**
+ * Vector search is supported via couchbase::cluster::search() or couchbase::scope::search()
+ */
+#define COUCHBASE_CXX_CLIENT_HAS_VECTOR_SEARCH 1
+
+/**
+ * Scope level search index management is supported via couchbase::scope::search_indexes()
+ */
+#define COUCHBASE_CXX_CLIENT_HAS_SCOPE_SEARCH_INDEX_MANAGEMENT 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);
         }
@@ -324,7 +327,12 @@ query_request::make_response(error_context::query&& ctx, const encoded_response_
                 response.ctx.first_error_message = response.meta.errors->front().message;
                 switch (response.ctx.first_error_code) {
                     case 1065: /* IKey: "service.io.request.unrecognized_parameter" */
-                        response.ctx.ec = errc::common::invalid_argument;
+                        if ((response.ctx.first_error_message.find("Unrecognized parameter in request") != std::string::npos) &&
+                            (response.ctx.first_error_message.find("preserve_expiry") != std::string::npos)) {
+                            response.ctx.ec = errc::common::feature_not_available;
+                        } else {
+                            response.ctx.ec = errc::common::invalid_argument;
+                        }
                         break;
                     case 1080: /* IKey: "timeout" */
                         response.ctx.ec = errc::common::unambiguous_timeout;
@@ -342,6 +350,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/document_search.cxx

@@ -34,6 +34,25 @@ search_request::encode_to(search_request::encoded_request_type& encoded, http_co
         { "query", utils::json::parse(query) },
         { "ctl", { { "timeout", encoded.timeout.count() } } },
     };
+
+    if (show_request.has_value()) {
+        body["showrequest"] = show_request.value() ? "true" : "false";
+    }
+
+    if (vector_search.has_value()) {
+        body["knn"] = utils::json::parse(vector_search.value());
+    }
+    if (vector_query_combination.has_value()) {
+        switch (*vector_query_combination) {
+            case couchbase::core::vector_query_combination::combination_or:
+                body["knn_operator"] = "or";
+                break;
+            case couchbase::core::vector_query_combination::combination_and:
+                body["knn_operator"] = "and";
+                break;
+        }
+    }
+
     if (explain) {
         body["explain"] = *explain;
     }
@@ -103,10 +122,15 @@ search_request::encode_to(search_request::encoded_request_type& encoded, http_co
         body[key] = utils::json::parse(value);
     }
 
+    if (bucket_name.has_value() && scope_name.has_value()) {
+        encoded.path = fmt::format("/api/bucket/{}/scope/{}/index/{}/query", bucket_name.value(), scope_name.value(), index_name);
+    } else {
+        encoded.path = fmt::format("/api/index/{}/query", index_name);
+    }
+
     encoded.type = type;
     encoded.headers["content-type"] = "application/json";
     encoded.method = "POST";
-    encoded.path = fmt::format("/api/index/{}/query", index_name);
     body_str = utils::json::generate(body);
     encoded.body = body_str;
     if (context.options.show_queries) {
@@ -310,6 +334,18 @@ search_request::make_response(error_context::search&& ctx, const encoded_respons
                 response.ctx.ec = errc::common::rate_limited;
                 return response;
             }
+        } else if (encoded.status_code == 404) {
+            tao::json::value payload{};
+            try {
+                payload = utils::json::parse(encoded.body.data());
+            } catch (const tao::pegtl::parse_error&) {
+                response.ctx.ec = errc::common::parsing_failure;
+                return response;
+            }
+            response.status = payload.at("status").get_string();
+            response.error = payload.at("error").get_string();
+            response.ctx.ec = errc::common::feature_not_available;
+            return response;
         }
         response.ctx.ec = errc::common::internal_server_failure;
     }

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

@@ -27,6 +27,7 @@
 #include "core/search_highlight_style.hxx"
 #include "core/search_scan_consistency.hxx"
 #include "core/timeout_defaults.hxx"
+#include "core/vector_query_combination.hxx"
 
 #include <couchbase/mutation_token.hxx>
 
@@ -118,6 +119,16 @@ struct search_request {
 
     std::string index_name;
     couchbase::core::json_string query;
+    std::optional<std::string> bucket_name;
+    std::optional<std::string> scope_name;
+
+    /**
+     * UNCOMMITTED: This should be set to false if using the .search() API, leave unset for old .search_query() API
+     */
+    std::optional<bool> show_request;
+
+    std::optional<couchbase::core::json_string> vector_search;
+    std::optional<couchbase::core::vector_query_combination> vector_query_combination;
 
     std::optional<std::uint32_t> limit{};
     std::optional<std::uint32_t> skip{};

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