couchbase 4.2.8 → 4.2.10

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

@@ -20,6 +20,8 @@
 #include "core/utils/json.hxx"
 #include "error_utils.hxx"
 
+#include <fmt/core.h>
+
 namespace couchbase::core::operations::management
 {
 std::error_code
@@ -29,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 {};
 }
 
@@ -64,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

@@ -20,6 +20,8 @@
 #include "core/utils/json.hxx"
 #include "error_utils.hxx"
 
+#include <fmt/core.h>
+
 namespace couchbase::core::operations::management
 {
 std::error_code
@@ -29,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 {};
 }
 
@@ -64,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

@@ -20,6 +20,8 @@
 #include "core/utils/json.hxx"
 #include "error_utils.hxx"
 
+#include <fmt/core.h>
+
 namespace couchbase::core::operations::management
 {
 std::error_code
@@ -29,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
@@ -63,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

@@ -21,6 +21,8 @@
 #include "core/utils/json.hxx"
 #include "error_utils.hxx"
 
+#include <fmt/core.h>
+
 namespace couchbase::core::operations::management
 {
 std::error_code
@@ -30,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 {};
 }
 
@@ -66,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 = fmt::format("/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

@@ -20,13 +20,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_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 {};
 }
 
@@ -50,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_get_stats.cxx

@@ -20,6 +20,8 @@
 #include "core/utils/json.hxx"
 #include "error_utils.hxx"
 
+#include <fmt/core.h>
+
 namespace couchbase::core::operations::management
 {
 std::error_code

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

@@ -21,6 +21,8 @@
 #include "core/utils/json.hxx"
 #include "error_utils.hxx"
 
+#include <fmt/core.h>
+
 namespace couchbase::core::operations::management
 {
 std::error_code
@@ -32,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 },
@@ -106,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/operations/management/view_index_drop.cxx

@@ -19,6 +19,8 @@
 
 #include "error_utils.hxx"
 
+#include <fmt/core.h>
+
 namespace couchbase::core::operations::management
 {
 std::error_code

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

@@ -20,6 +20,8 @@
 #include "core/utils/json.hxx"
 #include "error_utils.hxx"
 
+#include <fmt/core.h>
+
 namespace couchbase::core::operations::management
 {
 std::error_code

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

@@ -20,6 +20,8 @@
 #include "core/utils/json.hxx"
 #include "error_utils.hxx"
 
+#include <fmt/core.h>
+
 namespace couchbase::core::operations::management
 {
 std::error_code

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

@@ -20,6 +20,8 @@
 #include "core/utils/json.hxx"
 #include "error_utils.hxx"
 
+#include <fmt/core.h>
+
 namespace couchbase::core::operations::management
 {
 std::error_code

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

@@ -43,4 +43,3 @@
 #include "core/operations/document_upsert.hxx"
 #include "core/operations/document_view.hxx"
 #include "core/operations/http_noop.hxx"
-#include "core/operations/mcbp_noop.hxx"