couchbase 4.2.10 → 4.2.11-rc.1

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

@@ -426,7 +426,7 @@ class bucket_impl
                 }
                 self->update_config(cfg);
                 self->drain_deferred_queue();
-                self->fetch_config({});
+                self->poll_config({});
             }
             asio::post(asio::bind_executor(self->ctx_, [h = std::move(h), ec, cfg = std::move(cfg)]() mutable { h(ec, cfg); }));
         });
@@ -482,15 +482,11 @@ class bucket_impl
         }
     }
 
-    void fetch_config(std::error_code ec)
+    void fetch_config()
     {
-        if (ec == asio::error::operation_aborted || closed_) {
-            return;
-        }
-        if (heartbeat_timer_.expiry() > std::chrono::steady_clock::now()) {
+        if (closed_) {
             return;
         }
-
         std::optional<io::mcbp_session> session{};
         {
             std::scoped_lock lock(sessions_mutex_);
@@ -512,12 +508,25 @@ class bucket_impl
         } else {
             CB_LOG_WARNING(R"({} unable to find session with GCCCP support, retry in {})", log_prefix_, heartbeat_interval_);
         }
+    }
+
+    void poll_config(std::error_code ec)
+    {
+        if (ec == asio::error::operation_aborted || closed_) {
+            return;
+        }
+        if (heartbeat_timer_.expiry() > std::chrono::steady_clock::now()) {
+            return;
+        }
+
+        fetch_config();
+
         heartbeat_timer_.expires_after(heartbeat_interval_);
         return heartbeat_timer_.async_wait([self = shared_from_this()](std::error_code e) {
             if (e == asio::error::operation_aborted) {
                 return;
             }
-            self->fetch_config(e);
+            self->poll_config(e);
         });
     }
 
@@ -880,6 +889,12 @@ bucket::ping(std::shared_ptr<diag::ping_collector> collector, std::optional<std:
     return impl_->ping(std::move(collector), std::move(timeout));
 }
 
+void
+bucket::fetch_config()
+{
+    return impl_->fetch_config();
+}
+
 void
 bucket::update_config(topology::configuration config)
 {

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

@@ -177,6 +177,7 @@ class bucket
         });
     }
 
+    void fetch_config();
     void update_config(topology::configuration config) override;
     void bootstrap(utils::movable_function<void(std::error_code, topology::configuration)>&& handler);
     void with_configuration(utils::movable_function<void(std::error_code, topology::configuration)>&& handler);

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

@@ -114,6 +114,26 @@ class ping_collector_impl
     }
 };
 
+template<typename Request>
+constexpr bool
+is_feature_supported(const Request& /* request */, const configuration_capabilities& /* capabilities */)
+{
+    return true;
+}
+
+constexpr bool
+is_feature_supported(const operations::search_request& request, const configuration_capabilities& capabilities)
+{
+    if (request.scope_name && !capabilities.supports_scoped_search_indexes()) {
+        return false;
+    }
+    if (request.vector_search && !capabilities.supports_vector_search()) {
+        return false;
+    }
+
+    return true;
+}
+
 class cluster_impl : public std::enable_shared_from_this<cluster_impl>
 {
   public:
@@ -238,10 +258,14 @@ class cluster_impl : public std::enable_shared_from_this<cluster_impl>
             auto ptr = buckets_.find(bucket_name);
             if (ptr == buckets_.end()) {
                 std::vector<protocol::hello_feature> known_features;
+
+                auto origin = origin_;
                 if (session_ && session_->has_config()) {
                     known_features = session_->supported_features();
+                    origin = { origin_, session_->config().value() };
                 }
-                b = std::make_shared<bucket>(id_, ctx_, tls_, tracer_, meter_, bucket_name, origin_, known_features, dns_srv_tracker_);
+
+                b = std::make_shared<bucket>(id_, ctx_, tls_, tracer_, meter_, bucket_name, origin, known_features, dns_srv_tracker_);
                 buckets_.try_emplace(bucket_name, b);
             }
         }
@@ -326,6 +350,9 @@ class cluster_impl : public std::enable_shared_from_this<cluster_impl>
         if (stopped_) {
             return handler(request.make_response({ errc::network::cluster_closed }, response_type{}));
         }
+        if (!is_feature_supported(request, session_manager_->configuration_capabilities())) {
+            return handler(request.make_response({ errc::common::feature_not_available }, response_type{}));
+        }
         if constexpr (operations::is_compound_operation_v<Request>) {
             return request.execute(shared_from_this(), std::forward<Handler>(handler));
         } else {
@@ -355,8 +382,7 @@ class cluster_impl : public std::enable_shared_from_this<cluster_impl>
                         handler(request.make_response({ ec }, {}));
                         return;
                     }
-                    auto bucket_caps = config.bucket_capabilities;
-                    if (bucket_caps.find(cap) == bucket_caps.end()) {
+                    if (!config.capabilities.has_bucket_capability(cap)) {
                         handler(request.make_response({ errc::common::feature_not_available }, {}));
                         return;
                     }

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

@@ -479,7 +479,7 @@ class collection_impl : public std::enable_shared_from_this<collection_impl>
           bucket_name_,
           [core = core_, r = std::move(request), h = std::move(handler)](std::error_code ec,
                                                                          const core::topology::configuration& config) mutable {
-              if (!config.supports_subdoc_read_replica()) {
+              if (!config.capabilities.supports_subdoc_read_replica()) {
                   ec = errc::common::feature_not_available;
               }
 
@@ -601,7 +601,7 @@ class collection_impl : public std::enable_shared_from_this<collection_impl>
           bucket_name_,
           [core = core_, r = std::move(request), h = std::move(handler)](std::error_code ec,
                                                                          const core::topology::configuration& config) mutable {
-              if (!config.supports_subdoc_read_replica()) {
+              if (!config.capabilities.supports_subdoc_read_replica()) {
                   ec = errc::common::feature_not_available;
               }
               if (r->specs().size() > 16) {

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

@@ -215,7 +215,7 @@ class query_index_manager_impl : public std::enable_shared_from_this<query_index
                       const std::string& scope_name,
                       const std::string& collection_name,
                       std::string index_name,
-                      std::vector<std::string> fields,
+                      std::vector<std::string> keys,
                       const create_query_index_options::built& options,
                       create_query_index_handler&& handler) const
     {
@@ -225,7 +225,7 @@ class query_index_manager_impl : public std::enable_shared_from_this<query_index
             scope_name,
             collection_name,
             std::move(index_name),
-            std::move(fields),
+            std::move(keys),
             {},
             false /* is_primary */,
             options.ignore_if_exists,
@@ -521,22 +521,22 @@ collection_query_index_manager::get_all_indexes(const get_all_query_indexes_opti
 
 void
 collection_query_index_manager::create_index(std::string index_name,
-                                             std::vector<std::string> fields,
+                                             std::vector<std::string> keys,
                                              const create_query_index_options& options,
                                              create_query_index_handler&& handler) const
 {
     return impl_->create_index(
-      bucket_name_, scope_name_, collection_name_, std::move(index_name), std::move(fields), options.build(), std::move(handler));
+      bucket_name_, scope_name_, collection_name_, std::move(index_name), std::move(keys), options.build(), std::move(handler));
 }
 
 auto
 collection_query_index_manager::create_index(std::string index_name,
-                                             std::vector<std::string> fields,
+                                             std::vector<std::string> keys,
                                              const create_query_index_options& options) const -> std::future<manager_error_context>
 {
     auto barrier = std::make_shared<std::promise<manager_error_context>>();
     auto future = barrier->get_future();
-    create_index(std::move(index_name), std::move(fields), options, [barrier](auto ctx) { barrier->set_value(std::move(ctx)); });
+    create_index(std::move(index_name), std::move(keys), options, [barrier](auto ctx) { barrier->set_value(std::move(ctx)); });
     return future;
 }
 

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

@@ -58,6 +58,12 @@ class http_session_manager
         meter_ = std::move(meter);
     }
 
+    auto configuration_capabilities() const -> configuration_capabilities
+    {
+        std::scoped_lock config_lock(config_mutex_);
+        return config_.capabilities;
+    }
+
     void update_config(topology::configuration config) override
     {
         std::scoped_lock config_lock(config_mutex_, sessions_mutex_);
@@ -387,7 +393,7 @@ class http_session_manager
     cluster_options options_{};
 
     topology::configuration config_{};
-    std::mutex config_mutex_{};
+    mutable std::mutex config_mutex_{};
     std::map<service_type, std::list<std::shared_ptr<http_session>>> busy_sessions_{};
     std::map<service_type, std::list<std::shared_ptr<http_session>>> idle_sessions_{};
     std::size_t next_index_{ 0 };

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

@@ -289,6 +289,16 @@ struct mcbp_command : public std::enable_shared_from_this<mcbp_command<Manager,
               if (status == key_value_status_code::unknown_collection) {
                   return self->handle_unknown_collection();
               }
+              if (status == key_value_status_code::config_only) {
+                  CB_LOG_DEBUG(
+                    "{} server returned status 0x{:02x} ({}) meaning that the node does not serve data operations, requesting new "
+                    "configuration and retrying",
+                    self->session_->log_prefix(),
+                    msg.header.status(),
+                    status);
+                  self->manager_->fetch_config();
+                  return io::retry_orchestrator::maybe_retry(self->manager_, self, retry_reason::service_response_code_indicated, ec);
+              }
               if (error_code && error_code.value().has_retry_attribute()) {
                   reason = retry_reason::key_value_error_map_retry_indicated;
               } else {

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

@@ -455,6 +455,16 @@ class mcbp_session_impl
                         case protocol::client_opcode::get_cluster_config: {
                             protocol::cmd_info info{ session_->connection_endpoints_.remote_address,
                                                      session_->connection_endpoints_.remote.port() };
+                            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 get_cluster_config request (bootstrap, size={}, endpoint=\"{}:{}\"), {}",
+                                  session_->log_prefix_,
+                                  config_text.size(),
+                                  info.endpoint_address,
+                                  info.endpoint_port,
+                                  config_text);
+                            }
                             protocol::client_response<protocol::get_cluster_config_response_body> resp(std::move(msg), info);
                             if (resp.status() == key_value_status_code::success) {
                                 session_->update_configuration(resp.body().config());
@@ -860,6 +870,8 @@ class mcbp_session_impl
         if (stopped_) {
             return;
         }
+        bootstrapped_ = false;
+        bootstrap_handler_ = nullptr;
         state_ = diag::endpoint_state::connecting;
         if (stream_->is_open()) {
             std::string old_id = stream_->id();
@@ -1139,6 +1151,11 @@ class mcbp_session_impl
         return supports_gcccp_;
     }
 
+    std::optional<topology::configuration> config() const
+    {
+        return config_;
+    }
+
     [[nodiscard]] bool has_config() const
     {
         return configured_;
@@ -1539,7 +1556,7 @@ class mcbp_session_impl
                           CB_LOG_TRACE("{} MCBP recv {}", self->log_prefix_, mcbp_header_view(msg.header_data()));
                           if (self->bootstrapped_) {
                               self->handler_->handle(std::move(msg));
-                          } else {
+                          } else if (self->bootstrap_handler_) {
                               self->bootstrap_handler_->handle(std::move(msg));
                           }
                           if (self->stopped_) {
@@ -1818,6 +1835,12 @@ mcbp_session::index() const
     return impl_->index();
 }
 
+std::optional<topology::configuration>
+mcbp_session::config() const
+{
+    return impl_->config();
+}
+
 bool
 mcbp_session::has_config() const
 {

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

@@ -118,6 +118,7 @@ class mcbp_session
     void stop(retry_reason reason);
     [[nodiscard]] std::size_t index() const;
     [[nodiscard]] bool has_config() const;
+    [[nodiscard]] std::optional<topology::configuration> 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, std::optional<std::chrono::milliseconds> = {}) const;

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

@@ -32,7 +32,7 @@ struct design_document {
         std::optional<std::string> reduce{};
     };
 
-    std::string rev;
+    std::optional<std::string> rev;
     std::string name;
     design_document_namespace ns;
     std::map<std::string, view> views;

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

@@ -72,7 +72,7 @@
  */
 #define COUCHBASE_CXX_CLIENT_HAS_COLLECTION_QUERY_INDEX_MANAGEMENT 1
 
-#define COUCHBASE_CXX_CLIENT_TRANSACTIONS_EXT_PARALLEL_UNSTAGING
+#define COUCHBASE_CXX_CLIENT_TRANSACTIONS_EXT_PARALLEL_UNSTAGING 1
 
 /**
  * core cluster implementation has been hidden and not accessible through the public API
@@ -111,3 +111,18 @@
  * Scope level search index management is supported via couchbase::scope::search_indexes()
  */
 #define COUCHBASE_CXX_CLIENT_HAS_SCOPE_SEARCH_INDEX_MANAGEMENT 1
+
+/**
+ * Support for couchbase::codec::raw_json_transcoder
+ */
+#define COUCHBASE_CXX_CLIENT_HAS_RAW_JSON_TRANSCODER 1
+
+/**
+ * Support for couchbase::codec::raw_string_transcoder
+ */
+#define COUCHBASE_CXX_CLIENT_HAS_RAW_STRING_TRANSCODER 1
+
+/**
+ * Transaction's transaction_operation_failed has a public getter for its final_error
+ */
+#define COUCHBASE_CXX_CLIENT_TRANSACTIONS_CAN_FETCH_TO_RAISE 1

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

@@ -69,7 +69,7 @@ struct lookup_in_all_replicas_request {
           id.bucket(),
           [core, id = id, timeout = timeout, specs = specs, parent_span = parent_span, h = std::forward<Handler>(handler)](
             std::error_code ec, const topology::configuration& config) mutable {
-              if (!config.supports_subdoc_read_replica()) {
+              if (!config.capabilities.supports_subdoc_read_replica()) {
                   ec = errc::common::feature_not_available;
               }
 

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

@@ -66,7 +66,7 @@ struct lookup_in_any_replica_request {
           id.bucket(),
           [core, id = id, timeout = timeout, specs = specs, parent_span = parent_span, h = std::forward<Handler>(handler)](
             std::error_code ec, const topology::configuration& config) mutable {
-              if (!config.supports_subdoc_read_replica()) {
+              if (!config.capabilities.supports_subdoc_read_replica()) {
                   ec = errc::common::feature_not_available;
               }
               if (specs.size() > 16) {

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

@@ -47,7 +47,7 @@ query_request::encode_to(query_request::encoded_request_type& encoded, http_cont
             }
         } else {
             body["statement"] = "PREPARE " + statement;
-            if (context.config.supports_enhanced_prepared_statements()) {
+            if (context.config.capabilities.supports_enhanced_prepared_statements()) {
                 body["auto_execute"] = true;
             } else {
                 extract_encoded_plan_ = true;
@@ -87,7 +87,7 @@ query_request::encode_to(query_request::encoded_request_type& encoded, http_cont
             break;
     }
     if (use_replica.has_value()) {
-        if (context.config.supports_read_from_replica()) {
+        if (context.config.capabilities.supports_read_from_replica()) {
             if (use_replica.value()) {
                 body["use_replica"] = "on";
             } else {

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

@@ -36,20 +36,20 @@ search_request::encode_to(search_request::encoded_request_type& encoded, http_co
     };
 
     if (show_request.has_value()) {
-        body["showrequest"] = show_request.value() ? "true" : "false";
+        body["showrequest"] = show_request.value();
     }
 
     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 (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;
+            }
         }
     }
 

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

@@ -77,6 +77,9 @@ document_view_request::encode_to(document_view_request::encoded_request_type& en
     if (group_level) {
         query_string.emplace_back(fmt::format("group_level={}", *group_level));
     }
+    if (full_set) {
+        query_string.emplace_back(fmt::format("full_set={}", full_set.value() ? "true" : "false"));
+    }
     if (order) {
         switch (*order) {
             case couchbase::core::view_sort_order::descending:

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

@@ -86,6 +86,7 @@ struct document_view_request {
     std::optional<std::uint32_t> group_level;
     bool debug{ false };
     std::map<std::string, std::string> raw{};
+    std::optional<bool> full_set;
 
     std::optional<couchbase::core::view_sort_order> order;
     std::optional<couchbase::core::view_on_error> on_error;

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

@@ -17,7 +17,6 @@
 
 #include "query_index_create.hxx"
 
-#include "core/utils/join_strings.hxx"
 #include "core/utils/json.hxx"
 #include "core/utils/keyspace.hxx"
 #include "error_utils.hxx"
@@ -49,19 +48,31 @@ query_index_create_request::encode_to(encoded_request_type& encoded, http_contex
     if (with) {
         with_clause = fmt::format("WITH {}", utils::json::generate(with));
     }
+    std::string encoded_keys{};
+    for (std::size_t i = 0; i < keys.size(); i++) {
+        if (i != 0) {
+            encoded_keys += ", ";
+        }
+        auto key = keys.at(i);
+
+        // Add backticks around the key unless they are already present
+        if (key.at(0) == '`' && key.at(key.size() - 1) == '`') {
+            encoded_keys += key;
+        } else {
+            encoded_keys += fmt::format("`{}`", key);
+        }
+    }
     std::string keyspace = utils::build_keyspace(*this);
-    tao::json::value body{ { "statement",
-                             is_primary ? fmt::format(R"(CREATE PRIMARY INDEX {} ON {} USING GSI {})",
-                                                      index_name.empty() ? "" : fmt::format("`{}`", index_name),
-                                                      keyspace,
-                                                      with_clause)
-                                        : fmt::format(R"(CREATE INDEX `{}` ON {}({}) {} USING GSI {})",
-                                                      index_name,
-                                                      keyspace,
-                                                      utils::join_strings(fields, ", "),
-                                                      where_clause,
-                                                      with_clause) },
-                           { "client_context_id", encoded.client_context_id } };
+    tao::json::value body{
+        { "statement",
+          is_primary ? fmt::format(R"(CREATE PRIMARY INDEX {} ON {} USING GSI {})",
+                                   index_name.empty() ? "" : fmt::format("`{}`", index_name),
+                                   keyspace,
+                                   with_clause)
+                     : fmt::format(
+                         R"(CREATE INDEX `{}` ON {}({}) {} USING GSI {})", index_name, keyspace, encoded_keys, where_clause, with_clause) },
+        { "client_context_id", encoded.client_context_id }
+    };
     if (query_ctx.has_value()) {
         body["query_context"] = query_ctx.value();
     }

package/deps/couchbase-cxx-client/core/operations/management/query_index_create.hxx

@@ -49,7 +49,7 @@ struct query_index_create_request {
     std::string scope_name;
     std::string collection_name;
     std::string index_name{};
-    std::vector<std::string> fields;
+    std::vector<std::string> keys;
     query_context query_ctx;
     bool is_primary{ false };
     bool ignore_if_exists{ false };

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

@@ -18,6 +18,7 @@
 #include "origin.hxx"
 
 #include "core/utils/connection_string.hxx"
+#include "topology/configuration.hxx"
 
 #include <fmt/chrono.h>
 #include <fmt/core.h>
@@ -281,6 +282,19 @@ couchbase::core::origin::origin(const couchbase::core::origin& other)
   , next_node_(nodes_.begin())
 {
 }
+
+couchbase::core::origin::origin(const origin& other, const topology::configuration& config)
+  : origin(other)
+{
+    nodes_.clear();
+    for (const auto& node : config.nodes) {
+        if (auto port = options_.enable_tls ? node.services_tls.key_value : node.services_plain.key_value; port.has_value()) {
+            nodes_.emplace_back(node.hostname, std::to_string(port.value()));
+        }
+    }
+    next_node_ = nodes_.begin();
+}
+
 couchbase::core::origin::origin(couchbase::core::cluster_credentials auth,
                                 const std::string& hostname,
                                 std::uint16_t port,

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

@@ -40,6 +40,11 @@ struct cluster_credentials {
     [[nodiscard]] bool uses_certificate() const;
 };
 
+namespace topology
+{
+struct configuration;
+}
+
 struct origin {
     using node_entry = std::pair<std::string, std::string>;
     using node_list = std::vector<node_entry>;
@@ -49,6 +54,7 @@ struct origin {
 
     origin(origin&& other) = default;
     origin(const origin& other);
+    origin(const origin& other, const topology::configuration& config);
     origin(cluster_credentials auth, const std::string& hostname, std::uint16_t port, cluster_options options);
     origin(cluster_credentials auth, const std::string& hostname, const std::string& port, cluster_options options);
     origin(cluster_credentials auth, const utils::connection_string& connstr);

package/deps/couchbase-cxx-client/core/protocol/status.cxx

@@ -202,6 +202,8 @@ map_status_code(protocol::client_opcode opcode, std::uint16_t status)
 
         case key_value_status_code::unknown:
             break;
+        case key_value_status_code::config_only:
+            break;
     }
     return errc::network::protocol_error;
 }

package/deps/couchbase-cxx-client/core/protocol/status.hxx

@@ -103,6 +103,7 @@ is_valid_status(std::uint16_t code)
         case key_value_status_code::range_scan_more:
         case key_value_status_code::range_scan_complete:
         case key_value_status_code::range_scan_vb_uuid_not_equal:
+        case key_value_status_code::config_only:
             return true;
         case key_value_status_code::unknown:
             return false;

package/deps/couchbase-cxx-client/core/topology/capabilities.hxx

@@ -17,6 +17,8 @@
 
 #pragma once
 
+#include <set>
+
 namespace couchbase::core
 {
 enum class bucket_capability {
@@ -32,8 +34,15 @@ enum class bucket_capability {
     durable_write,
     tombstoned_user_xattrs,
     range_scan,
-    replica_read,
     non_deduped_history,
+    subdoc_replace_body_with_xattr,
+    subdoc_document_macro_support,
+    subdoc_revive_document,
+    dcp_ignore_purged_tombstones,
+    preserve_expiry,
+    query_system_collection,
+    mobile_system_collection,
+    subdoc_replica_read,
 };
 
 enum class cluster_capability {
@@ -43,5 +52,65 @@ enum class cluster_capability {
     n1ql_inline_functions,
     n1ql_enhanced_prepared_statements,
     n1ql_read_from_replica,
+    search_vector_search,
+    search_scoped_search_index,
+};
+
+struct configuration_capabilities {
+    std::set<bucket_capability> bucket{};
+    std::set<cluster_capability> cluster{};
+
+    [[nodiscard]] bool has_cluster_capability(cluster_capability cap) const
+    {
+        return cluster.find(cap) != cluster.end();
+    }
+
+    [[nodiscard]] bool has_bucket_capability(bucket_capability cap) const
+    {
+        return bucket.find(cap) != bucket.end();
+    }
+
+    [[nodiscard]] bool supports_enhanced_prepared_statements() const
+    {
+        return has_cluster_capability(cluster_capability::n1ql_enhanced_prepared_statements);
+    }
+
+    [[nodiscard]] bool supports_read_from_replica() const
+    {
+        return has_cluster_capability(cluster_capability::n1ql_read_from_replica);
+    }
+
+    [[nodiscard]] bool supports_range_scan() const
+    {
+        return has_bucket_capability(bucket_capability::range_scan);
+    }
+
+    [[nodiscard]] bool ephemeral() const
+    {
+        // Use bucket capabilities to identify if couchapi is missing (then its ephemeral). If its null then
+        // we are running an old version of couchbase which doesn't have ephemeral buckets at all.
+        return has_bucket_capability(bucket_capability::couchapi);
+    }
+
+    [[nodiscard]] bool supports_subdoc_read_replica() const
+    {
+        return has_bucket_capability(bucket_capability::subdoc_replica_read);
+    }
+
+    [[nodiscard]] bool supports_non_deduped_history() const
+    {
+        return has_bucket_capability(bucket_capability::non_deduped_history);
+    }
+
+    [[nodiscard]] bool supports_scoped_search_indexes() const
+    {
+        return has_cluster_capability(cluster_capability::search_scoped_search_index);
+    }
+
+    [[nodiscard]] bool supports_vector_search() const
+    {
+        return has_cluster_capability(cluster_capability::search_vector_search);
+    }
 };
+
 } // namespace couchbase::core