couchbase 4.2.9 → 4.2.11-rc.1

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

@@ -42,6 +42,9 @@ struct search_index_control_ingest_request {
     std::string index_name;
     bool pause;
 
+    std::optional<std::string> bucket_name;
+    std::optional<std::string> scope_name;
+
     std::optional<std::string> client_context_id{};
     std::optional<std::chrono::milliseconds> timeout{};
 

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

@@ -31,7 +31,15 @@ search_index_control_plan_freeze_request::encode_to(encoded_request_type& encode
         return errc::common::invalid_argument;
     }
     encoded.method = "POST";
-    encoded.path = fmt::format("/api/index/{}/planFreezeControl/{}", index_name, freeze ? "freeze" : "unfreeze");
+    if (bucket_name.has_value() && scope_name.has_value()) {
+        encoded.path = fmt::format("/api/bucket/{}/scope/{}/index/{}/planFreezeControl/{}",
+                                   bucket_name.value(),
+                                   scope_name.value(),
+                                   index_name,
+                                   freeze ? "freeze" : "unfreeze");
+    } else {
+        encoded.path = fmt::format("/api/index/{}/planFreezeControl/{}", index_name, freeze ? "freeze" : "unfreeze");
+    }
     return {};
 }
 
@@ -66,6 +74,18 @@ search_index_control_plan_freeze_request::make_response(error_context::http&& ct
                 response.ctx.ec = errc::common::index_not_found;
                 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 = extract_common_error_code(encoded.status_code, encoded.body.data());
     }

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

@@ -44,6 +44,9 @@ struct search_index_control_plan_freeze_request {
     std::string index_name;
     bool freeze;
 
+    std::optional<std::string> bucket_name;
+    std::optional<std::string> scope_name;
+
     std::optional<std::string> client_context_id{};
     std::optional<std::chrono::milliseconds> timeout{};
 

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

@@ -31,7 +31,15 @@ search_index_control_query_request::encode_to(encoded_request_type& encoded, htt
         return errc::common::invalid_argument;
     }
     encoded.method = "POST";
-    encoded.path = fmt::format("/api/index/{}/queryControl/{}", index_name, allow ? "allow" : "disallow");
+    if (bucket_name.has_value() && scope_name.has_value()) {
+        encoded.path = fmt::format("/api/bucket/{}/scope/{}/index/{}/queryControl/{}",
+                                   bucket_name.value(),
+                                   scope_name.value(),
+                                   index_name,
+                                   allow ? "allow" : "disallow");
+    } else {
+        encoded.path = fmt::format("/api/index/{}/queryControl/{}", index_name, allow ? "allow" : "disallow");
+    }
     return {};
 }
 
@@ -66,6 +74,18 @@ search_index_control_query_request::make_response(error_context::http&& ctx, con
                 response.ctx.ec = errc::common::index_not_found;
                 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 = extract_common_error_code(encoded.status_code, encoded.body.data());
     }

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

@@ -42,6 +42,9 @@ struct search_index_control_query_request {
     std::string index_name;
     bool allow;
 
+    std::optional<std::string> bucket_name;
+    std::optional<std::string> scope_name;
+
     std::optional<std::string> client_context_id{};
     std::optional<std::chrono::milliseconds> timeout{};
 

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

@@ -31,7 +31,11 @@ search_index_drop_request::encode_to(encoded_request_type& encoded, http_context
         return errc::common::invalid_argument;
     }
     encoded.method = "DELETE";
-    encoded.path = fmt::format("/api/index/{}", index_name);
+    if (bucket_name.has_value() && scope_name.has_value()) {
+        encoded.path = fmt::format("/api/bucket/{}/scope/{}/index/{}", bucket_name.value(), scope_name.value(), index_name);
+    } else {
+        encoded.path = fmt::format("/api/index/{}", index_name);
+    }
     return {};
 }
 search_index_drop_response
@@ -65,6 +69,18 @@ search_index_drop_request::make_response(error_context::http&& ctx, const encode
                 response.ctx.ec = errc::common::index_not_found;
                 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 = extract_common_error_code(encoded.status_code, encoded.body.data());
     }

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

@@ -41,6 +41,9 @@ struct search_index_drop_request {
 
     std::string index_name;
 
+    std::optional<std::string> bucket_name;
+    std::optional<std::string> scope_name;
+
     std::optional<std::string> client_context_id{};
     std::optional<std::chrono::milliseconds> timeout{};
 

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

@@ -32,7 +32,11 @@ search_index_get_request::encode_to(encoded_request_type& encoded, http_context&
         return errc::common::invalid_argument;
     }
     encoded.method = "GET";
-    encoded.path = fmt::format("/api/index/{}", index_name);
+    if (bucket_name.has_value() && scope_name.has_value()) {
+        encoded.path = fmt::format("/api/bucket/{}/scope/{}/index/{}", bucket_name.value(), scope_name.value(), index_name);
+    } else {
+        encoded.path = fmt::format("/api/index/{}", index_name);
+    }
     return {};
 }
 
@@ -68,6 +72,18 @@ search_index_get_request::make_response(error_context::http&& ctx, const encoded
                 response.ctx.ec = errc::common::index_not_found;
                 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 = extract_common_error_code(encoded.status_code, encoded.body.data());
     }

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

@@ -42,6 +42,8 @@ struct search_index_get_request {
     static const inline service_type type = service_type::search;
 
     std::string index_name;
+    std::optional<std::string> bucket_name;
+    std::optional<std::string> scope_name;
 
     std::optional<std::string> client_context_id{};
     std::optional<std::chrono::milliseconds> timeout{};

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

@@ -21,13 +21,19 @@
 #include "core/utils/json.hxx"
 #include "error_utils.hxx"
 
+#include <fmt/core.h>
+
 namespace couchbase::core::operations::management
 {
 std::error_code
 search_index_get_all_request::encode_to(encoded_request_type& encoded, http_context& /* context */) const
 {
     encoded.method = "GET";
-    encoded.path = "/api/index";
+    if (bucket_name.has_value() && scope_name.has_value()) {
+        encoded.path = fmt::format("/api/bucket/{}/scope/{}/index", bucket_name.value(), scope_name.value());
+    } else {
+        encoded.path = "/api/index";
+    }
     return {};
 }
 
@@ -36,30 +42,41 @@ search_index_get_all_request::make_response(error_context::http&& ctx, const enc
 {
     search_index_get_all_response response{ std::move(ctx) };
     if (!response.ctx.ec) {
-        if (encoded.status_code != 200) {
-            response.ctx.ec = extract_common_error_code(encoded.status_code, encoded.body.data());
-            return response;
-        }
-        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();
-        if (response.status != "ok") {
-            return response;
-        }
-        if (const auto* indexDefs = payload.find("indexDefs"); indexDefs != nullptr && indexDefs->is_object()) {
-            if (const auto* impl_ver = indexDefs->find("implVersion"); impl_ver != nullptr && impl_ver->is_string()) {
-                response.impl_version = impl_ver->get_string();
+        if (encoded.status_code == 200) {
+            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();
+            if (response.status != "ok") {
+                return response;
             }
-            const auto* indexes = indexDefs->find("indexDefs");
-            for (const auto& [name, index] : indexes->get_object()) {
-                response.indexes.emplace_back(index.as<couchbase::core::management::search::index>());
+            if (const auto* indexDefs = payload.find("indexDefs"); indexDefs != nullptr && indexDefs->is_object()) {
+                if (const auto* impl_ver = indexDefs->find("implVersion"); impl_ver != nullptr && impl_ver->is_string()) {
+                    response.impl_version = impl_ver->get_string();
+                }
+                const auto* indexes = indexDefs->find("indexDefs");
+                for (const auto& [name, index] : indexes->get_object()) {
+                    response.indexes.emplace_back(index.as<couchbase::core::management::search::index>());
+                }
+                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.ctx.ec = errc::common::feature_not_available;
+            return response;
         }
+        response.ctx.ec = extract_common_error_code(encoded.status_code, encoded.body.data());
     }
     return response;
 }

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

@@ -41,6 +41,9 @@ struct search_index_get_all_request {
 
     static const inline service_type type = service_type::search;
 
+    std::optional<std::string> bucket_name;
+    std::optional<std::string> scope_name;
+
     std::optional<std::string> client_context_id{};
     std::optional<std::chrono::milliseconds> timeout{};
 

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

@@ -28,7 +28,11 @@ std::error_code
 search_index_get_documents_count_request::encode_to(encoded_request_type& encoded, http_context& /* context */) const
 {
     encoded.method = "GET";
-    encoded.path = fmt::format("/api/index/{}/count", index_name);
+    if (bucket_name.has_value() && scope_name.has_value()) {
+        encoded.path = fmt::format("/api/bucket/{}/scope/{}/index/{}/count", bucket_name.value(), scope_name.value(), index_name);
+    } else {
+        encoded.path = fmt::format("/api/index/{}/count", index_name);
+    }
     return {};
 }
 
@@ -52,6 +56,19 @@ search_index_get_documents_count_request::make_response(error_context::http&& ct
                     return response;
                 }
             } break;
+            case 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;
+            }
             case 400:
             case 500: {
                 tao::json::value payload{};

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

@@ -42,6 +42,9 @@ struct search_index_get_documents_count_request {
 
     std::string index_name;
 
+    std::optional<std::string> bucket_name;
+    std::optional<std::string> scope_name;
+
     std::optional<std::string> client_context_id{};
     std::optional<std::chrono::milliseconds> timeout{};
 

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

@@ -34,7 +34,11 @@ search_index_upsert_request::encode_to(encoded_request_type& encoded, http_conte
     encoded.method = "PUT";
     encoded.headers["cache-control"] = "no-cache";
     encoded.headers["content-type"] = "application/json";
-    encoded.path = fmt::format("/api/index/{}", index.name);
+    if (bucket_name.has_value() && scope_name.has_value()) {
+        encoded.path = fmt::format("/api/bucket/{}/scope/{}/index/{}", bucket_name.value(), scope_name.value(), index.name);
+    } else {
+        encoded.path = fmt::format("/api/index/{}", index.name);
+    }
     tao::json::value body{
         { "name", index.name },
         { "type", index.type },
@@ -108,6 +112,18 @@ search_index_upsert_request::make_response(error_context::http&& ctx, const enco
                 response.ctx.ec = errc::common::quota_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 = extract_common_error_code(encoded.status_code, encoded.body.data());
     }

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

@@ -44,6 +44,9 @@ struct search_index_upsert_request {
 
     couchbase::core::management::search::index index;
 
+    std::optional<std::string> bucket_name;
+    std::optional<std::string> scope_name;
+
     std::optional<std::string> client_context_id{};
     std::optional<std::chrono::milliseconds> timeout{};
 

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

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

@@ -70,12 +70,33 @@ struct fmt::formatter<couchbase::core::bucket_capability> {
             case couchbase::core::bucket_capability::range_scan:
                 name = "range_scan";
                 break;
-            case couchbase::core::bucket_capability::replica_read:
-                name = "replica_read";
+            case couchbase::core::bucket_capability::subdoc_replica_read:
+                name = "subdoc_replica_read";
                 break;
             case couchbase::core::bucket_capability::non_deduped_history:
                 name = "non_deduped_history";
                 break;
+            case couchbase::core::bucket_capability::subdoc_replace_body_with_xattr:
+                name = "subdoc_replace_body_with_xattr";
+                break;
+            case couchbase::core::bucket_capability::subdoc_document_macro_support:
+                name = "subdoc_document_macro_support";
+                break;
+            case couchbase::core::bucket_capability::subdoc_revive_document:
+                name = "subdoc_revive_document";
+                break;
+            case couchbase::core::bucket_capability::dcp_ignore_purged_tombstones:
+                name = "dcp_ignore_purged_tombstones";
+                break;
+            case couchbase::core::bucket_capability::preserve_expiry:
+                name = "preserve_expiry";
+                break;
+            case couchbase::core::bucket_capability::query_system_collection:
+                name = "query_system_collection";
+                break;
+            case couchbase::core::bucket_capability::mobile_system_collection:
+                name = "mobile_system_collection";
+                break;
         }
         return format_to(ctx.out(), "{}", name);
     }
@@ -111,6 +132,13 @@ struct fmt::formatter<couchbase::core::cluster_capability> {
                 break;
             case couchbase::core::cluster_capability::n1ql_read_from_replica:
                 name = "n1ql_read_from_replica";
+                break;
+            case couchbase::core::cluster_capability::search_vector_search:
+                name = "search_vector_search";
+                break;
+            case couchbase::core::cluster_capability::search_scoped_search_index:
+                name = "search_scoped_search_index";
+                break;
         }
         return format_to(ctx.out(), "{}", name);
     }

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

@@ -28,7 +28,7 @@ struct collections_manifest {
     struct collection {
         std::uint64_t uid;
         std::string name;
-        std::uint32_t max_expiry{ 0 };
+        std::int32_t max_expiry{ 0 };
         std::optional<bool> history{};
     };
 

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

@@ -41,7 +41,7 @@ struct traits<couchbase::core::topology::collections_manifest> {
                 collection.uid = std::stoull(c.at("uid").get_string(), nullptr, 16);
                 collection.name = c.at("name").get_string();
                 if (const auto* max_ttl = c.find("maxTTL"); max_ttl != nullptr) {
-                    collection.max_expiry = max_ttl->template as<std::uint32_t>();
+                    collection.max_expiry = max_ttl->template as<std::int32_t>();
                 }
                 if (const auto* history = c.find("history"); history != nullptr) {
                     collection.history = history->template as<std::optional<bool>>();

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

@@ -89,8 +89,7 @@ struct configuration {
     std::optional<std::string> bucket{};
     std::optional<vbucket_map> vbmap{};
     std::optional<std::uint64_t> collections_manifest_uid{};
-    std::set<bucket_capability> bucket_capabilities{};
-    std::set<cluster_capability> cluster_capabilities{};
+    configuration_capabilities capabilities{};
     node_locator_type node_locator{ node_locator_type::unknown };
     bool force{ false };
 
@@ -111,38 +110,6 @@ struct configuration {
 
     [[nodiscard]] std::string rev_str() const;
 
-    [[nodiscard]] bool supports_enhanced_prepared_statements() const
-    {
-        return cluster_capabilities.find(cluster_capability::n1ql_enhanced_prepared_statements) != cluster_capabilities.end();
-    }
-
-    [[nodiscard]] bool supports_read_from_replica() const
-    {
-        return cluster_capabilities.find(cluster_capability::n1ql_read_from_replica) != cluster_capabilities.end();
-    }
-
-    [[nodiscard]] bool supports_range_scan() const
-    {
-        return bucket_capabilities.find(bucket_capability::range_scan) != bucket_capabilities.end();
-    }
-
-    [[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 bucket_capabilities.count(couchbase::core::bucket_capability::couchapi) == 0;
-    }
-
-    [[nodiscard]] bool supports_subdoc_read_replica() const
-    {
-        return bucket_capabilities.find(bucket_capability::replica_read) != bucket_capabilities.end();
-    }
-
-    [[nodiscard]] bool supports_non_deduped_history() const
-    {
-        return bucket_capabilities.find(bucket_capability::non_deduped_history) != bucket_capabilities.end();
-    }
-
     [[nodiscard]] std::size_t index_for_this_node() const;
     [[nodiscard]] bool has_node(const std::string& network,
                                 service_type type,