couchbase 4.2.9 → 4.2.11-rc.1

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());
@@ -542,17 +552,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 }
         {
         }
 
@@ -563,16 +567,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)
@@ -709,23 +707,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:
@@ -889,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();
@@ -1168,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_;
@@ -1400,6 +1388,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) {
@@ -1419,19 +1408,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);
@@ -1553,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_) {
@@ -1832,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
 {
@@ -1892,4 +1901,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

@@ -109,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,
@@ -117,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/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/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
@@ -101,3 +101,28 @@
  * 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
+
+/**
+ * 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 {
@@ -327,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;

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();
+    }
+
+    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/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/collection_create.cxx

@@ -28,14 +28,18 @@
 namespace couchbase::core::operations::management
 {
 std::error_code
-collection_create_request::encode_to(encoded_request_type& encoded, http_context& /* context */) const
+collection_create_request::encode_to(encoded_request_type& encoded, http_context& /*context*/) const
 {
     encoded.method = "POST";
     encoded.path = fmt::format("/pools/default/buckets/{}/scopes/{}/collections", bucket_name, scope_name);
     encoded.headers["content-type"] = "application/x-www-form-urlencoded";
     encoded.body = fmt::format("name={}", utils::string_codec::form_encode(collection_name));
-    if (max_expiry > 0) {
-        encoded.body.append(fmt::format("&maxTTL={}", max_expiry));
+    if (max_expiry >= -1) {
+        if (max_expiry != 0) {
+            encoded.body.append(fmt::format("&maxTTL={}", max_expiry));
+        }
+    } else {
+        return couchbase::errc::common::invalid_argument;
     }
     if (history.has_value()) {
         encoded.body.append(fmt::format("&history={}", history.value()));
@@ -53,9 +57,6 @@ collection_create_request::make_response(error_context::http&& ctx, const encode
                 std::regex collection_exists("Collection with name .+ already exists");
                 if (std::regex_search(encoded.body.data(), collection_exists)) {
                     response.ctx.ec = errc::management::collection_exists;
-                } else if (encoded.body.data().find("Not allowed on this version of cluster") != std::string::npos ||
-                           encoded.body.data().find("Bucket must have storage_mode=magma") != std::string::npos) {
-                    response.ctx.ec = errc::common::feature_not_available;
                 } else {
                     response.ctx.ec = errc::common::invalid_argument;
                 }

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

@@ -41,7 +41,7 @@ struct collection_create_request {
     std::string bucket_name;
     std::string scope_name;
     std::string collection_name;
-    std::uint32_t max_expiry{ 0 };
+    std::int32_t max_expiry{ 0 };
     std::optional<bool> history{};
 
     std::optional<std::string> client_context_id{};

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

@@ -28,14 +28,18 @@
 namespace couchbase::core::operations::management
 {
 std::error_code
-collection_update_request::encode_to(encoded_request_type& encoded, http_context& /* context */) const
+collection_update_request::encode_to(encoded_request_type& encoded, http_context& /*context*/) const
 {
     encoded.method = "PATCH";
     encoded.path = fmt::format("/pools/default/buckets/{}/scopes/{}/collections/{}", bucket_name, scope_name, collection_name);
     encoded.headers["content-type"] = "application/x-www-form-urlencoded";
     std::map<std::string, std::string> values{};
     if (max_expiry.has_value()) {
-        values["maxTTL"] = std::to_string(max_expiry.value());
+        if (max_expiry.value() >= -1) {
+            values["maxTTL"] = std::to_string(max_expiry.value());
+        } else {
+            return errc::common::invalid_argument;
+        }
     }
     if (history.has_value()) {
         values["history"] = history.value() ? "true" : "false";
@@ -51,12 +55,7 @@ collection_update_request::make_response(error_context::http&& ctx, const encode
     if (!response.ctx.ec) {
         switch (encoded.status_code) {
             case 400: {
-                if (encoded.body.data().find("Not allowed on this version of cluster") != std::string::npos ||
-                    encoded.body.data().find("Bucket must have storage_mode=magma") != std::string::npos) {
-                    response.ctx.ec = errc::common::feature_not_available;
-                } else {
-                    response.ctx.ec = errc::common::invalid_argument;
-                }
+                response.ctx.ec = errc::common::invalid_argument;
             } break;
             case 404: {
                 std::regex scope_not_found("Scope with name .+ is not found");

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

@@ -41,7 +41,7 @@ struct collection_update_request {
     std::string bucket_name;
     std::string scope_name;
     std::string collection_name;
-    std::optional<std::uint32_t> max_expiry{};
+    std::optional<std::int32_t> max_expiry{};
     std::optional<bool> history{};
 
     std::optional<std::string> client_context_id{};

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

@@ -47,6 +47,9 @@ extract_common_query_error_code(std::uint64_t code, const std::string& message)
         case 1194: /* ICode: E_SERVICE_USER_RESULT_SIZE_EXCEEDED, IKey: "service.result.size.exceeded" */
             return errc::common::rate_limited;
 
+        case 13014: /*ICode: E_DATASTORE_INSUFFICIENT_CREDENTIALS, IKey: "datastore.couchbase.insufficient_credentials" */
+            return errc::common::authentication_failure;
+
         case 5000:
             if (message.find("Limit for number of indexes that can be created per scope has been reached") != std::string::npos) {
                 return errc::common::quota_limited;

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/operations/management/search_index_analyze_document.cxx

@@ -33,7 +33,11 @@ search_index_analyze_document_request::encode_to(encoded_request_type& encoded,
     encoded.method = "POST";
     encoded.headers["cache-control"] = "no-cache";
     encoded.headers["content-type"] = "application/json";
-    encoded.path = fmt::format("/api/index/{}/analyzeDoc", index_name);
+    if (bucket_name.has_value() && scope_name.has_value()) {
+        encoded.path = fmt::format("/api/bucket/{}/scope/{}/index/{}/analyzeDoc", bucket_name.value(), scope_name.value(), index_name);
+    } else {
+        encoded.path = fmt::format("/api/index/{}/analyzeDoc", index_name);
+    }
     encoded.body = encoded_document;
     return {};
 }
@@ -78,6 +82,18 @@ search_index_analyze_document_request::make_response(error_context::http&& ctx,
                 response.ctx.ec = errc::common::index_exists;
                 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_analyze_document.hxx

@@ -43,6 +43,9 @@ struct search_index_analyze_document_request {
     std::string index_name;
     std::string encoded_document;
 
+    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_ingest.cxx

@@ -31,7 +31,15 @@ search_index_control_ingest_request::encode_to(encoded_request_type& encoded, ht
         return errc::common::invalid_argument;
     }
     encoded.method = "POST";
-    encoded.path = fmt::format("/api/index/{}/ingestControl/{}", index_name, pause ? "pause" : "resume");
+    if (bucket_name.has_value() && scope_name.has_value()) {
+        encoded.path = fmt::format("/api/bucket/{}/scope/{}/index/{}/ingestControl/{}",
+                                   bucket_name.value(),
+                                   scope_name.value(),
+                                   index_name,
+                                   pause ? "pause" : "resume");
+    } else {
+        encoded.path = fmt::format("/api/index/{}/ingestControl/{}", index_name, pause ? "pause" : "resume");
+    }
     return {};
 }
 
@@ -66,6 +74,18 @@ search_index_control_ingest_request::make_response(error_context::http&& ctx, co
                 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());
     }