couchbase 4.2.9 → 4.2.10

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

@@ -0,0 +1,139 @@
+/* -*- Mode: C++; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */
+/*
+ *   Copyright 2023-Present Couchbase, Inc.
+ *
+ *   Licensed under the Apache License, Version 2.0 (the "License");
+ *   you may not use this file except in compliance with the License.
+ *   You may obtain a copy of the License at
+ *
+ *       http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *   Unless required by applicable law or agreed to in writing, software
+ *   distributed under the License is distributed on an "AS IS" BASIS,
+ *   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *   See the License for the specific language governing permissions and
+ *   limitations under the License.
+ */
+
+#include "core/impl/encoded_search_query.hxx"
+
+#include <couchbase/search_request.hxx>
+
+namespace couchbase
+{
+class search_request_impl
+{
+  public:
+    explicit search_request_impl(std::optional<encoded_search_query> search_query,
+                                 std::optional<encoded_search_query> vector_search,
+                                 std::optional<vector_search_options::built> options)
+      : search_query_(std::move(search_query))
+      , vector_search_(std::move(vector_search))
+      , vector_search_options_(std::move(options))
+    {
+    }
+
+    static search_request_impl create(const search_query& query)
+    {
+        auto encoded = query.encode();
+        if (encoded.ec) {
+            throw std::system_error(encoded.ec, "unable to encode the search_query");
+        }
+        return search_request_impl(encoded, {}, {});
+    }
+
+    static search_request_impl create(const vector_search& search)
+    {
+        auto encoded = search.encode();
+        if (encoded.ec) {
+            throw std::system_error(encoded.ec, "unable to encode the vector_search");
+        }
+        return search_request_impl({}, encoded, search.options());
+    }
+
+    void search_query(const couchbase::search_query& query)
+    {
+        search_query_ = query.encode();
+        if (search_query_.value().ec) {
+            throw std::system_error(search_query_.value().ec, "unable to encode the search_query");
+        }
+    }
+
+    void vector_search(const couchbase::vector_search& search)
+    {
+        vector_search_ = search.encode();
+        if (vector_search_.value().ec) {
+            throw std::system_error(vector_search_.value().ec, "unable to encode the vector_search");
+        }
+        vector_search_options_ = search.options();
+    }
+
+    [[nodiscard]] std::optional<encoded_search_query> search_query() const
+    {
+        return search_query_;
+    }
+
+    [[nodiscard]] std::optional<encoded_search_query> vector_search() const
+    {
+        return vector_search_;
+    }
+
+    [[nodiscard]] std::optional<vector_search_options::built> vector_options() const
+    {
+        return vector_search_options_;
+    }
+
+  private:
+    std::optional<encoded_search_query> search_query_;
+    std::optional<encoded_search_query> vector_search_;
+    std::optional<vector_search_options::built> vector_search_options_;
+};
+
+search_request::search_request(const couchbase::search_query& query)
+  : impl_{ std::make_shared<search_request_impl>(search_request_impl::create(query)) }
+{
+}
+
+search_request::search_request(const couchbase::vector_search& search)
+  : impl_{ std::make_shared<search_request_impl>(search_request_impl::create(search)) }
+{
+}
+
+auto
+search_request::search_query(const couchbase::search_query& search_query) -> search_request&
+{
+    if (impl_->search_query().has_value()) {
+        throw std::invalid_argument("There can only be one search_query in a search request");
+    }
+    impl_->search_query(search_query);
+    return *this;
+}
+
+auto
+search_request::vector_search(const couchbase::vector_search& vector_search) -> search_request&
+{
+    if (impl_->vector_search().has_value()) {
+        throw std::invalid_argument("There can only be one vector_search in a search request");
+    }
+    impl_->vector_search(vector_search);
+    return *this;
+}
+
+[[nodiscard]] std::optional<encoded_search_query>
+search_request::search_query() const
+{
+    return impl_->search_query();
+}
+
+[[nodiscard]] std::optional<encoded_search_query>
+search_request::vector_search() const
+{
+    return impl_->vector_search();
+}
+
+[[nodiscard]] std::optional<couchbase::vector_search_options::built>
+search_request::vector_options()
+{
+    return impl_->vector_options();
+}
+} // namespace couchbase

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

@@ -0,0 +1,42 @@
+/* -*- Mode: C++; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */
+/*
+ *   Copyright 2023-Present Couchbase, Inc.
+ *
+ *   Licensed under the Apache License, Version 2.0 (the "License");
+ *   you may not use this file except in compliance with the License.
+ *   You may obtain a copy of the License at
+ *
+ *       http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *   Unless required by applicable law or agreed to in writing, software
+ *   distributed under the License is distributed on an "AS IS" BASIS,
+ *   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *   See the License for the specific language governing permissions and
+ *   limitations under the License.
+ */
+
+#include "encoded_search_query.hxx"
+
+#include <couchbase/vector_query.hxx>
+
+namespace couchbase
+{
+auto
+vector_query::encode() const -> encoded_search_query
+{
+    encoded_search_query built;
+    built.query = tao::json::empty_object;
+    if (boost_) {
+        built.query["boost"] = boost_.value();
+    }
+    built.query["field"] = vector_field_name_;
+
+    tao::json::value vector_values = tao::json::empty_array;
+    for (const auto value : vector_query_) {
+        vector_values.push_back(value);
+    }
+    built.query["vector"] = vector_values;
+    built.query["k"] = num_candidates_;
+    return built;
+}
+} // namespace couchbase

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

@@ -0,0 +1,40 @@
+/* -*- Mode: C++; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */
+/*
+ *   Copyright 2023-Present Couchbase, Inc.
+ *
+ *   Licensed under the Apache License, Version 2.0 (the "License");
+ *   you may not use this file except in compliance with the License.
+ *   You may obtain a copy of the License at
+ *
+ *       http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *   Unless required by applicable law or agreed to in writing, software
+ *   distributed under the License is distributed on an "AS IS" BASIS,
+ *   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *   See the License for the specific language governing permissions and
+ *   limitations under the License.
+ */
+
+#include "encoded_search_query.hxx"
+
+#include <couchbase/vector_search.hxx>
+
+namespace couchbase
+{
+auto
+vector_search::encode() const -> encoded_search_query
+{
+    encoded_search_query built;
+
+    built.query = tao::json::empty_array;
+
+    for (const auto& query : vector_queries_) {
+        auto encoded = query.encode();
+        if (encoded.ec) {
+            return { encoded.ec };
+        }
+        built.query.push_back(encoded.query);
+    }
+    return built;
+}
+} // namespace couchbase

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

@@ -370,11 +370,12 @@ class http_session : public std::enable_shared_from_this<http_session>
             return;
         }
         if (ec) {
-            CB_LOG_ERROR("{} error on resolve: {}", info_.log_prefix(), ec.message());
+            CB_LOG_ERROR("{} error on resolve \"{}:{}\": {}", info_.log_prefix(), hostname_, service_, ec.message());
             return;
         }
         last_active_ = std::chrono::steady_clock::now();
         endpoints_ = endpoints;
+        CB_LOG_TRACE("{} resolved \"{}:{}\" to {} endpoint(s)", info_.log_prefix(), hostname_, service_, endpoints_.size());
         do_connect(endpoints_.begin());
         deadline_timer_.async_wait(std::bind(&http_session::check_deadline, shared_from_this(), std::placeholders::_1));
     }
@@ -385,15 +386,17 @@ class http_session : public std::enable_shared_from_this<http_session>
             return;
         }
         if (it != endpoints_.end()) {
-            CB_LOG_DEBUG("{} connecting to {}:{}, timeout={}ms",
+            CB_LOG_DEBUG("{} connecting to {}:{} (\"{}:{}\"), timeout={}ms",
                          info_.log_prefix(),
                          it->endpoint().address().to_string(),
                          it->endpoint().port(),
+                         hostname_,
+                         service_,
                          http_ctx_.options.connect_timeout.count());
             deadline_timer_.expires_after(http_ctx_.options.connect_timeout);
             stream_->async_connect(it->endpoint(), std::bind(&http_session::on_connect, shared_from_this(), std::placeholders::_1, it));
         } else {
-            CB_LOG_ERROR("{} no more endpoints left to connect", info_.log_prefix());
+            CB_LOG_ERROR("{} no more endpoints left to connect, \"{}:{}\" is not reachable", info_.log_prefix(), hostname_, service_);
             stop();
         }
     }

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

@@ -542,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 }
         {
         }
 
@@ -563,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)
@@ -709,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:
@@ -1400,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) {
@@ -1419,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);
@@ -1892,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

@@ -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,

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/meta/features.hxx

@@ -101,3 +101,13 @@
  * 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

@@ -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() ? "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/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/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{};