couchbase 4.2.9 → 4.2.10

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());
     }

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/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/transactions/internal/utils.hxx

@@ -242,6 +242,7 @@ struct exp_delay {
     std::chrono::nanoseconds timeout;
     mutable std::uint32_t retries;
     mutable std::optional<std::chrono::time_point<std::chrono::steady_clock>> end_time;
+    std::size_t max_retries{ 100 };
 
     template<typename R1, typename P1, typename R2, typename P2, typename R3, typename P3>
     exp_delay(std::chrono::duration<R1, P1> initial, std::chrono::duration<R2, P2> max, std::chrono::duration<R3, P3> limit)
@@ -255,6 +256,9 @@ struct exp_delay {
     void operator()() const
     {
         auto now = std::chrono::steady_clock::now();
+        if (retries >= max_retries) {
+            throw retry_operation_retries_exhausted("retries exhausted");
+        }
         if (!end_time) {
             end_time = std::chrono::steady_clock::now() + timeout;
             return;

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

@@ -0,0 +1,23 @@
+/* -*- Mode: C++; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */
+/*
+ *   Copyright 2020-2021 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.
+ */
+
+#pragma once
+
+namespace couchbase::core
+{
+enum class vector_query_combination { combination_and, combination_or };
+} // namespace couchbase::core

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

@@ -19,6 +19,7 @@
 
 #include <couchbase/collection.hxx>
 #include <couchbase/collection_manager.hxx>
+#include <couchbase/ping_options.hxx>
 #include <couchbase/scope.hxx>
 
 #include <memory>
@@ -74,6 +75,34 @@ class bucket
      */
     [[nodiscard]] auto scope(std::string_view scope_name) const -> scope;
 
+    /**
+     * Performs application-level ping requests against services in the Couchbase cluster.
+     *
+     * @note This operation performs active I/O against services and endpoints to assess their health. If you do not
+     * wish to performs I/O, consider using @ref diagnostics() instead.
+     *
+     * @param options custom options to change the default behavior.
+     * @param handler the handler that implements @ref ping_handler.
+     *
+     * @since 1.0.0
+     * @committed
+     */
+    void ping(const ping_options& options, ping_handler&& handler) const;
+
+    /**
+     * Performs application-level ping requests against services in the Couchbase cluster.
+     *
+     * @note This operation performs active I/O against services and endpoints to assess their health. If you do not
+     * wish to performs I/O, consider using @ref diagnostics() instead.
+     *
+     * @param options custom options to change the default behavior.
+     * @return future object that carries result of the operation.
+     *
+     * @since 1.0.0
+     * @committed
+     */
+    [[nodiscard]] auto ping(const ping_options& options = {}) const -> std::future<ping_result>;
+
     /**
      * Provides access to the collection management services.
      *