couchbase 4.0.0 → 4.1.0

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

@@ -58,14 +58,14 @@ extract_common_query_error_code(std::uint64_t code, const std::string& message)
     return {};
 }
 
-std::pair<std::error_code, eventing::problem>
+std::pair<std::error_code, eventing_problem>
 extract_eventing_error_code(const tao::json::value& response)
 {
     if (!response.is_object()) {
         return {};
     }
     if (const auto& name = response.find("name"); name != nullptr && name->is_string()) {
-        eventing::problem problem{
+        eventing_problem problem{
             response.at("code").get_unsigned(),
             name->get_string(),
             response.at("description").get_string(),

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

@@ -33,7 +33,7 @@ extract_common_error_code(std::uint32_t status_code, const std::string& response
 std::optional<std::error_code>
 extract_common_query_error_code(std::uint64_t code, const std::string& message);
 
-std::pair<std::error_code, eventing::problem>
+std::pair<std::error_code, eventing_problem>
 extract_eventing_error_code(const tao::json::value& response);
 
 std::optional<std::error_code>

package/deps/couchbase-cxx-client/couchbase/operations/management/eventing_deploy_function.hxx

@@ -20,7 +20,7 @@
 #include <couchbase/error_context/http.hxx>
 #include <couchbase/io/http_context.hxx>
 #include <couchbase/io/http_message.hxx>
-#include <couchbase/operations/management/eventing_function.hxx>
+#include <couchbase/management/eventing_function.hxx>
 #include <couchbase/operations/management/eventing_problem.hxx>
 #include <couchbase/platform/uuid.h>
 #include <couchbase/timeout_defaults.hxx>
@@ -29,7 +29,7 @@ namespace couchbase::operations::management
 {
 struct eventing_deploy_function_response {
     error_context::http ctx;
-    std::optional<eventing::problem> error{};
+    std::optional<eventing_problem> error{};
 };
 
 struct eventing_deploy_function_request {

package/deps/couchbase-cxx-client/couchbase/operations/management/eventing_drop_function.hxx

@@ -20,7 +20,7 @@
 #include <couchbase/error_context/http.hxx>
 #include <couchbase/io/http_context.hxx>
 #include <couchbase/io/http_message.hxx>
-#include <couchbase/operations/management/eventing_function.hxx>
+#include <couchbase/management/eventing_function.hxx>
 #include <couchbase/operations/management/eventing_problem.hxx>
 #include <couchbase/platform/uuid.h>
 #include <couchbase/timeout_defaults.hxx>
@@ -29,7 +29,7 @@ namespace couchbase::operations::management
 {
 struct eventing_drop_function_response {
     error_context::http ctx;
-    std::optional<eventing::problem> error{};
+    std::optional<eventing_problem> error{};
 };
 
 struct eventing_drop_function_request {

package/deps/couchbase-cxx-client/couchbase/operations/management/eventing_get_all_functions.cxx

@@ -16,8 +16,8 @@
  */
 
 #include <couchbase/errors.hxx>
+#include <couchbase/management/eventing_function_json.hxx>
 #include <couchbase/operations/management/error_utils.hxx>
-#include <couchbase/operations/management/eventing_function_json.hxx>
 #include <couchbase/operations/management/eventing_get_all_functions.hxx>
 #include <couchbase/utils/json.hxx>
 
@@ -56,7 +56,7 @@ eventing_get_all_functions_request::make_response(error_context::http&& ctx, con
         const auto& entries = payload.get_array();
         response.functions.reserve(entries.size());
         for (const auto& entry : entries) {
-            response.functions.emplace_back(entry.as<eventing::function>());
+            response.functions.emplace_back(entry.as<couchbase::management::eventing::function>());
         }
     }
     return response;

package/deps/couchbase-cxx-client/couchbase/operations/management/eventing_get_all_functions.hxx

@@ -20,7 +20,7 @@
 #include <couchbase/error_context/http.hxx>
 #include <couchbase/io/http_context.hxx>
 #include <couchbase/io/http_message.hxx>
-#include <couchbase/operations/management/eventing_function.hxx>
+#include <couchbase/management/eventing_function.hxx>
 #include <couchbase/operations/management/eventing_problem.hxx>
 #include <couchbase/platform/uuid.h>
 #include <couchbase/timeout_defaults.hxx>
@@ -29,8 +29,8 @@ namespace couchbase::operations::management
 {
 struct eventing_get_all_functions_response {
     error_context::http ctx;
-    std::vector<eventing::function> functions{};
-    std::optional<eventing::problem> error{};
+    std::vector<couchbase::management::eventing::function> functions{};
+    std::optional<eventing_problem> error{};
 };
 
 struct eventing_get_all_functions_request {

package/deps/couchbase-cxx-client/couchbase/operations/management/eventing_get_function.cxx

@@ -16,8 +16,8 @@
  */
 
 #include <couchbase/errors.hxx>
+#include <couchbase/management/eventing_function_json.hxx>
 #include <couchbase/operations/management/error_utils.hxx>
-#include <couchbase/operations/management/eventing_function_json.hxx>
 #include <couchbase/operations/management/eventing_get_function.hxx>
 #include <couchbase/utils/json.hxx>
 
@@ -49,7 +49,7 @@ eventing_get_function_request::make_response(error_context::http&& ctx, const en
             response.error.emplace(problem);
             return response;
         }
-        response.function = payload.as<eventing::function>();
+        response.function = payload.as<couchbase::management::eventing::function>();
     }
     return response;
 }

package/deps/couchbase-cxx-client/couchbase/operations/management/eventing_get_function.hxx

@@ -20,7 +20,7 @@
 #include <couchbase/error_context/http.hxx>
 #include <couchbase/io/http_context.hxx>
 #include <couchbase/io/http_message.hxx>
-#include <couchbase/operations/management/eventing_function.hxx>
+#include <couchbase/management/eventing_function.hxx>
 #include <couchbase/operations/management/eventing_problem.hxx>
 #include <couchbase/platform/uuid.h>
 #include <couchbase/timeout_defaults.hxx>
@@ -29,8 +29,8 @@ namespace couchbase::operations::management
 {
 struct eventing_get_function_response {
     error_context::http ctx;
-    eventing::function function{};
-    std::optional<eventing::problem> error{};
+    couchbase::management::eventing::function function{};
+    std::optional<eventing_problem> error{};
 };
 
 struct eventing_get_function_request {

package/deps/couchbase-cxx-client/couchbase/operations/management/eventing_get_status.cxx

@@ -16,9 +16,9 @@
  */
 
 #include <couchbase/errors.hxx>
+#include <couchbase/management/eventing_status_json.hxx>
 #include <couchbase/operations/management/error_utils.hxx>
 #include <couchbase/operations/management/eventing_get_status.hxx>
-#include <couchbase/operations/management/eventing_status_json.hxx>
 #include <couchbase/utils/json.hxx>
 
 namespace couchbase::operations::management
@@ -49,7 +49,7 @@ eventing_get_status_request::make_response(error_context::http&& ctx, const enco
             response.error.emplace(problem);
             return response;
         }
-        response.status = payload.as<eventing::status>();
+        response.status = payload.as<couchbase::management::eventing::status>();
     }
     return response;
 }

package/deps/couchbase-cxx-client/couchbase/operations/management/eventing_get_status.hxx

@@ -20,9 +20,9 @@
 #include <couchbase/error_context/http.hxx>
 #include <couchbase/io/http_context.hxx>
 #include <couchbase/io/http_message.hxx>
-#include <couchbase/operations/management/eventing_function.hxx>
+#include <couchbase/management/eventing_function.hxx>
+#include <couchbase/management/eventing_status.hxx>
 #include <couchbase/operations/management/eventing_problem.hxx>
-#include <couchbase/operations/management/eventing_status.hxx>
 #include <couchbase/platform/uuid.h>
 #include <couchbase/timeout_defaults.hxx>
 
@@ -31,8 +31,8 @@ namespace couchbase::operations::management
 
 struct eventing_get_status_response {
     error_context::http ctx;
-    eventing::status status{};
-    std::optional<eventing::problem> error{};
+    couchbase::management::eventing::status status{};
+    std::optional<eventing_problem> error{};
 };
 
 struct eventing_get_status_request {

package/deps/couchbase-cxx-client/couchbase/operations/management/eventing_pause_function.hxx

@@ -20,7 +20,7 @@
 #include <couchbase/error_context/http.hxx>
 #include <couchbase/io/http_context.hxx>
 #include <couchbase/io/http_message.hxx>
-#include <couchbase/operations/management/eventing_function.hxx>
+#include <couchbase/management/eventing_function.hxx>
 #include <couchbase/operations/management/eventing_problem.hxx>
 #include <couchbase/platform/uuid.h>
 #include <couchbase/timeout_defaults.hxx>
@@ -29,7 +29,7 @@ namespace couchbase::operations::management
 {
 struct eventing_pause_function_response {
     error_context::http ctx;
-    std::optional<eventing::problem> error{};
+    std::optional<eventing_problem> error{};
 };
 
 struct eventing_pause_function_request {

package/deps/couchbase-cxx-client/couchbase/operations/management/eventing_problem.hxx

@@ -19,13 +19,13 @@
 
 #include <string>
 
-namespace couchbase::operations::management::eventing
+namespace couchbase::operations::management
 {
 
-struct problem {
+struct eventing_problem {
     std::uint64_t code{};
     std::string name{};
     std::string description{};
 };
 
-} // namespace couchbase::operations::management::eventing
+} // namespace couchbase::operations::management

package/deps/couchbase-cxx-client/couchbase/operations/management/eventing_resume_function.hxx

@@ -20,7 +20,7 @@
 #include <couchbase/error_context/http.hxx>
 #include <couchbase/io/http_context.hxx>
 #include <couchbase/io/http_message.hxx>
-#include <couchbase/operations/management/eventing_function.hxx>
+#include <couchbase/management/eventing_function.hxx>
 #include <couchbase/operations/management/eventing_problem.hxx>
 #include <couchbase/platform/uuid.h>
 #include <couchbase/timeout_defaults.hxx>
@@ -29,7 +29,7 @@ namespace couchbase::operations::management
 {
 struct eventing_resume_function_response {
     error_context::http ctx;
-    std::optional<eventing::problem> error{};
+    std::optional<eventing_problem> error{};
 };
 
 struct eventing_resume_function_request {

package/deps/couchbase-cxx-client/couchbase/operations/management/eventing_undeploy_function.hxx

@@ -20,7 +20,7 @@
 #include <couchbase/error_context/http.hxx>
 #include <couchbase/io/http_context.hxx>
 #include <couchbase/io/http_message.hxx>
-#include <couchbase/operations/management/eventing_function.hxx>
+#include <couchbase/management/eventing_function.hxx>
 #include <couchbase/operations/management/eventing_problem.hxx>
 #include <couchbase/platform/uuid.h>
 #include <couchbase/timeout_defaults.hxx>
@@ -29,7 +29,7 @@ namespace couchbase::operations::management
 {
 struct eventing_undeploy_function_response {
     error_context::http ctx;
-    std::optional<eventing::problem> error{};
+    std::optional<eventing_problem> error{};
 };
 
 struct eventing_undeploy_function_request {

package/deps/couchbase-cxx-client/couchbase/operations/management/eventing_upsert_function.cxx

@@ -80,20 +80,20 @@ eventing_upsert_function_request::encode_to(encoded_request_type& encoded, http_
                 { "allow_cookies", url.allow_cookies },
                 { "validate_ssl_certificate", url.validate_ssl_certificate },
             };
-            if (std::holds_alternative<eventing::function_url_no_auth>(url.auth)) {
+            if (std::holds_alternative<couchbase::management::eventing::function_url_no_auth>(url.auth)) {
                 binding["auth_type"] = "no-auth";
-            } else if (std::holds_alternative<eventing::function_url_auth_basic>(url.auth)) {
-                const auto& auth = std::get<eventing::function_url_auth_basic>(url.auth);
+            } else if (std::holds_alternative<couchbase::management::eventing::function_url_auth_basic>(url.auth)) {
+                const auto& auth = std::get<couchbase::management::eventing::function_url_auth_basic>(url.auth);
                 binding["auth_type"] = "basic";
                 binding["username"] = auth.username;
                 binding["password"] = auth.password;
-            } else if (std::holds_alternative<eventing::function_url_auth_digest>(url.auth)) {
-                const auto& auth = std::get<eventing::function_url_auth_digest>(url.auth);
+            } else if (std::holds_alternative<couchbase::management::eventing::function_url_auth_digest>(url.auth)) {
+                const auto& auth = std::get<couchbase::management::eventing::function_url_auth_digest>(url.auth);
                 binding["auth_type"] = "digest";
                 binding["username"] = auth.username;
                 binding["password"] = auth.password;
-            } else if (std::holds_alternative<eventing::function_url_auth_bearer>(url.auth)) {
-                const auto& auth = std::get<eventing::function_url_auth_bearer>(url.auth);
+            } else if (std::holds_alternative<couchbase::management::eventing::function_url_auth_bearer>(url.auth)) {
+                const auto& auth = std::get<couchbase::management::eventing::function_url_auth_bearer>(url.auth);
                 binding["auth_type"] = "bearer";
                 binding["bearer_key"] = auth.key;
             }
@@ -116,10 +116,10 @@ eventing_upsert_function_request::encode_to(encoded_request_type& encoded, http_
                 binding["collection_name"] = bucket.name.collection;
             }
             switch (bucket.access) {
-                case eventing::function_bucket_access::read_only:
+                case couchbase::management::eventing::function_bucket_access::read_only:
                     binding["access"] = "r";
                     break;
-                case eventing::function_bucket_access::read_write:
+                case couchbase::management::eventing::function_bucket_access::read_write:
                     binding["access"] = "rw";
                     break;
             }
@@ -132,10 +132,10 @@ eventing_upsert_function_request::encode_to(encoded_request_type& encoded, http_
 
     if (function.settings.processing_status) {
         switch (function.settings.processing_status.value()) {
-            case eventing::function_processing_status::running:
+            case couchbase::management::eventing::function_processing_status::running:
                 settings["processing_status"] = true;
                 break;
-            case eventing::function_processing_status::paused:
+            case couchbase::management::eventing::function_processing_status::paused:
                 settings["processing_status"] = false;
                 break;
         }
@@ -145,10 +145,10 @@ eventing_upsert_function_request::encode_to(encoded_request_type& encoded, http_
 
     if (function.settings.deployment_status) {
         switch (function.settings.deployment_status.value()) {
-            case eventing::function_deployment_status::deployed:
+            case couchbase::management::eventing::function_deployment_status::deployed:
                 settings["deployment_status"] = true;
                 break;
-            case eventing::function_deployment_status::undeployed:
+            case couchbase::management::eventing::function_deployment_status::undeployed:
                 settings["deployment_status"] = false;
                 break;
         }
@@ -162,10 +162,10 @@ eventing_upsert_function_request::encode_to(encoded_request_type& encoded, http_
 
     if (function.settings.dcp_stream_boundary) {
         switch (function.settings.dcp_stream_boundary.value()) {
-            case eventing::function_dcp_boundary::everything:
+            case couchbase::management::eventing::function_dcp_boundary::everything:
                 settings["dcp_stream_boundary"] = "everything";
                 break;
-            case eventing::function_dcp_boundary::from_now:
+            case couchbase::management::eventing::function_dcp_boundary::from_now:
                 settings["dcp_stream_boundary"] = "from_now";
                 break;
         }
@@ -177,19 +177,19 @@ eventing_upsert_function_request::encode_to(encoded_request_type& encoded, http_
 
     if (function.settings.log_level) {
         switch (function.settings.log_level.value()) {
-            case eventing::function_log_level::info:
+            case couchbase::management::eventing::function_log_level::info:
                 settings["log_level"] = "INFO";
                 break;
-            case eventing::function_log_level::error:
+            case couchbase::management::eventing::function_log_level::error:
                 settings["log_level"] = "ERROR";
                 break;
-            case eventing::function_log_level::warning:
+            case couchbase::management::eventing::function_log_level::warning:
                 settings["log_level"] = "WARNING";
                 break;
-            case eventing::function_log_level::debug:
+            case couchbase::management::eventing::function_log_level::debug:
                 settings["log_level"] = "DEBUG";
                 break;
-            case eventing::function_log_level::trace:
+            case couchbase::management::eventing::function_log_level::trace:
                 settings["log_level"] = "TRACE";
                 break;
         }
@@ -197,13 +197,13 @@ eventing_upsert_function_request::encode_to(encoded_request_type& encoded, http_
 
     if (function.settings.language_compatibility) {
         switch (function.settings.language_compatibility.value()) {
-            case eventing::function_language_compatibility::version_6_0_0:
+            case couchbase::management::eventing::function_language_compatibility::version_6_0_0:
                 settings["language_compatibility"] = "6.0.0";
                 break;
-            case eventing::function_language_compatibility::version_6_5_0:
+            case couchbase::management::eventing::function_language_compatibility::version_6_5_0:
                 settings["language_compatibility"] = "6.5.0";
                 break;
-            case eventing::function_language_compatibility::version_6_6_2:
+            case couchbase::management::eventing::function_language_compatibility::version_6_6_2:
                 settings["language_compatibility"] = "6.6.2";
                 break;
         }
@@ -295,10 +295,10 @@ eventing_upsert_function_request::encode_to(encoded_request_type& encoded, http_
 
     if (function.settings.query_consistency) {
         switch (function.settings.query_consistency.value()) {
-            case eventing::query_scan_consistency::not_bounded:
+            case couchbase::query_scan_consistency::not_bounded:
                 settings["n1ql_consistency"] = "none";
                 break;
-            case eventing::query_scan_consistency::request_plus:
+            case couchbase::query_scan_consistency::request_plus:
                 settings["n1ql_consistency"] = "request";
                 break;
         }

package/deps/couchbase-cxx-client/couchbase/operations/management/eventing_upsert_function.hxx

@@ -20,7 +20,7 @@
 #include <couchbase/error_context/http.hxx>
 #include <couchbase/io/http_context.hxx>
 #include <couchbase/io/http_message.hxx>
-#include <couchbase/operations/management/eventing_function.hxx>
+#include <couchbase/management/eventing_function.hxx>
 #include <couchbase/operations/management/eventing_problem.hxx>
 #include <couchbase/platform/uuid.h>
 #include <couchbase/timeout_defaults.hxx>
@@ -29,7 +29,7 @@ namespace couchbase::operations::management
 {
 struct eventing_upsert_function_response {
     error_context::http ctx;
-    std::optional<eventing::problem> error{};
+    std::optional<eventing_problem> error{};
 };
 
 struct eventing_upsert_function_request {
@@ -38,7 +38,7 @@ struct eventing_upsert_function_request {
     using encoded_response_type = io::http_response;
     using error_context_type = error_context::http;
 
-    eventing::function function{};
+    couchbase::management::eventing::function function{};
 
     static const inline service_type type = service_type::eventing;
 

package/deps/couchbase-cxx-client/couchbase/operations/management/group_get.cxx

@@ -18,8 +18,8 @@
 #include <couchbase/operations/management/group_get.hxx>
 
 #include <couchbase/errors.hxx>
+#include <couchbase/management/rbac_json.hxx>
 #include <couchbase/operations/management/error_utils.hxx>
-#include <couchbase/operations/management/rbac_json.hxx>
 #include <couchbase/utils/json.hxx>
 
 namespace couchbase::operations::management
@@ -41,7 +41,7 @@ group_get_request::make_response(error_context::http&& ctx, const encoded_respon
         switch (encoded.status_code) {
             case 200: {
                 try {
-                    response.group = utils::json::parse(encoded.body.data()).as<rbac::group>();
+                    response.group = utils::json::parse(encoded.body.data()).as<couchbase::management::rbac::group>();
                 } catch (const tao::pegtl::parse_error&) {
                     response.ctx.ec = error::common_errc::parsing_failure;
                     return response;

package/deps/couchbase-cxx-client/couchbase/operations/management/group_get.hxx

@@ -17,18 +17,18 @@
 
 #pragma once
 
-#include <couchbase/platform/uuid.h>
+#include <couchbase/error_context/http.hxx>
 #include <couchbase/io/http_context.hxx>
 #include <couchbase/io/http_message.hxx>
+#include <couchbase/management/rbac.hxx>
+#include <couchbase/platform/uuid.h>
 #include <couchbase/timeout_defaults.hxx>
-#include <couchbase/error_context/http.hxx>
-#include <couchbase/operations/management/rbac.hxx>
 
 namespace couchbase::operations::management
 {
 struct group_get_response {
     error_context::http ctx;
-    rbac::group group{};
+    couchbase::management::rbac::group group{};
 };
 
 struct group_get_request {

package/deps/couchbase-cxx-client/couchbase/operations/management/group_get_all.cxx

@@ -18,8 +18,8 @@
 #include <couchbase/operations/management/group_get_all.hxx>
 
 #include <couchbase/errors.hxx>
+#include <couchbase/management/rbac_json.hxx>
 #include <couchbase/operations/management/error_utils.hxx>
-#include <couchbase/operations/management/rbac_json.hxx>
 #include <couchbase/utils/json.hxx>
 
 namespace couchbase::operations::management
@@ -50,7 +50,7 @@ group_get_all_request::make_response(error_context::http&& ctx, const encoded_re
             return response;
         }
         for (const auto& entry : payload.get_array()) {
-            response.groups.emplace_back(entry.as<rbac::group>());
+            response.groups.emplace_back(entry.as<couchbase::management::rbac::group>());
         }
     }
     return response;

package/deps/couchbase-cxx-client/couchbase/operations/management/group_get_all.hxx

@@ -20,7 +20,7 @@
 #include <couchbase/error_context/http.hxx>
 #include <couchbase/io/http_context.hxx>
 #include <couchbase/io/http_message.hxx>
-#include <couchbase/operations/management/rbac.hxx>
+#include <couchbase/management/rbac.hxx>
 #include <couchbase/platform/uuid.h>
 #include <couchbase/timeout_defaults.hxx>
 
@@ -28,7 +28,7 @@ namespace couchbase::operations::management
 {
 struct group_get_all_response {
     error_context::http ctx;
-    std::vector<rbac::group> groups{};
+    std::vector<couchbase::management::rbac::group> groups{};
 };
 
 struct group_get_all_request {

package/deps/couchbase-cxx-client/couchbase/operations/management/group_upsert.hxx

@@ -20,7 +20,7 @@
 #include <couchbase/error_context/http.hxx>
 #include <couchbase/io/http_context.hxx>
 #include <couchbase/io/http_message.hxx>
-#include <couchbase/operations/management/rbac.hxx>
+#include <couchbase/management/rbac.hxx>
 #include <couchbase/platform/uuid.h>
 #include <couchbase/timeout_defaults.hxx>
 
@@ -39,7 +39,7 @@ struct group_upsert_request {
 
     static const inline service_type type = service_type::management;
 
-    rbac::group group{};
+    couchbase::management::rbac::group group{};
 
     std::optional<std::string> client_context_id{};
     std::optional<std::chrono::milliseconds> timeout{};

package/deps/couchbase-cxx-client/couchbase/operations/management/query_index_build_deferred.cxx

@@ -26,14 +26,27 @@ namespace couchbase::operations::management
 std::error_code
 query_index_build_deferred_request::encode_to(encoded_request_type& encoded, http_context& /* context */) const
 {
+    if ((scope_name.empty() && !collection_name.empty()) || (!scope_name.empty() && collection_name.empty())) {
+        return error::common_errc::invalid_argument;
+    }
+    std::string statement;
+    if (!scope_name.empty() && !collection_name.empty()) {
+        statement = fmt::format(
+          R"(BUILD INDEX ON `{}`.`{}`.`{}` ((SELECT RAW name FROM system:indexes WHERE bucket_id = "{}" AND scope_id = "{}" AND keyspace_id = "{}" AND state = "deferred")))",
+          bucket_name,
+          scope_name,
+          collection_name,
+          bucket_name,
+          scope_name,
+          collection_name);
+    } else {
+        statement = fmt::format(
+          R"(BUILD INDEX ON `{}` ((SELECT RAW name FROM system:indexes WHERE keyspace_id = "{}" AND bucket_id IS MISSING AND state = "deferred")))",
+          bucket_name,
+          bucket_name);
+    }
     encoded.headers["content-type"] = "application/json";
-    tao::json::value body{
-        { "statement",
-          fmt::format(R"(BUILD INDEX ON `{}` ((SELECT RAW name FROM system:indexes WHERE keyspace_id = "{}" AND state = "deferred")))",
-                      bucket_name,
-                      bucket_name) },
-        { "client_context_id", encoded.client_context_id }
-    };
+    tao::json::value body{ { "statement", statement }, { "client_context_id", encoded.client_context_id } };
     encoded.method = "POST";
     encoded.path = "/query/service";
     encoded.body = utils::json::generate(body);

package/deps/couchbase-cxx-client/couchbase/operations/management/query_index_build_deferred.hxx

@@ -46,6 +46,8 @@ struct query_index_build_deferred_request {
     static const inline service_type type = service_type::query;
 
     std::string bucket_name;
+    std::string scope_name;
+    std::string collection_name;
 
     std::optional<std::string> client_context_id{};
     std::optional<std::chrono::milliseconds> timeout{};

package/deps/couchbase-cxx-client/couchbase/operations/management/query_index_create.cxx

@@ -27,6 +27,9 @@ namespace couchbase::operations::management
 std::error_code
 query_index_create_request::encode_to(encoded_request_type& encoded, http_context&) const
 {
+    if ((scope_name.empty() && !collection_name.empty()) || (!scope_name.empty() && collection_name.empty())) {
+        return error::common_errc::invalid_argument;
+    }
     encoded.headers["content-type"] = "application/json";
     tao::json::value with{};
     if (deferred) {
@@ -85,6 +88,8 @@ query_index_create_request::make_response(error_context::http&& ctx, const encod
         if (response.status != "success") {
             bool index_already_exists = false;
             bool bucket_not_found = false;
+            bool collection_not_found = false;
+            bool scope_not_found = false;
             std::optional<std::error_code> common_ec{};
             for (const auto& entry : payload.at("errors").get_array()) {
                 query_index_create_response::query_problem error;
@@ -101,7 +106,15 @@ query_index_create_request::make_response(error_context::http&& ctx, const encod
                         break;
 
                     case 12003: /* IKey: "datastore.couchbase.keyspace_not_found" */
-                        bucket_not_found = true;
+                        if (error.message.find("missing_collection") != std::string::npos) {
+                            collection_not_found = true;
+                        } else {
+                            bucket_not_found = true;
+                        }
+                        break;
+
+                    case 12021:
+                        scope_not_found = true;
                         break;
 
                     case 4300: /* IKey: "plan.new_index_already_exists" */
@@ -120,6 +133,10 @@ query_index_create_request::make_response(error_context::http&& ctx, const encod
                 }
             } else if (bucket_not_found) {
                 response.ctx.ec = error::common_errc::bucket_not_found;
+            } else if (collection_not_found) {
+                response.ctx.ec = error::common_errc::collection_not_found;
+            } else if (scope_not_found) {
+                response.ctx.ec = error::common_errc::scope_not_found;
             } else if (common_ec) {
                 response.ctx.ec = common_ec.value();
             } else if (!response.errors.empty()) {