couchbase 3.8.2 → 3.9.0

data/ext/couchbase/core/operations/management/error_utils.cxx

@@ -28,6 +28,10 @@ auto
 extract_common_error_code(std::uint32_t status_code, const std::string& response_body)
   -> std::error_code
 {
+  // RFC-58: a 400 that reaches this fallback is invalid_argument.
+  if (status_code == 400) {
+    return errc::common::invalid_argument;
+  }
   if (status_code == 429) {
     if (response_body.find("Limit(s) exceeded") != std::string::npos) {
       return errc::common::rate_limited;
@@ -59,6 +63,7 @@ extract_common_query_error_code(std::uint64_t code, const std::string& message)
 
     case 13014: /* ICode: E_DATASTORE_INSUFFICIENT_CREDENTIALS, IKey:
                    "datastore.couchbase.insufficient_credentials" */
+    case 2120:  /* ICode: E_ADMIN_AUTH, IKey: "admin.clustering.authorize" */
       return errc::common::authentication_failure;
 
     case 5000:
@@ -73,15 +78,26 @@ extract_common_query_error_code(std::uint64_t code, const std::string& message)
       break;
   }
 
+  // RFC-58 maps these ranges whatever the HTTP status, so a 400 carrying one is not
+  // invalid_argument.
+  if (code >= 5000 && code < 6000) {
+    return errc::common::internal_server_failure;
+  }
+  if (code >= 10000 && code < 11000) {
+    return errc::common::authentication_failure;
+  }
   return {};
 }
 
 auto
-extract_eventing_error_code(const tao::json::value& response)
+extract_eventing_error_code(const tao::json::value& response, std::uint32_t status_code)
   -> std::pair<std::error_code, eventing_problem>
 {
+  // RFC-58: a 400 that names no specific problem is invalid_argument.
+  const std::error_code unmatched_400 =
+    status_code == 400 ? errc::common::invalid_argument : std::error_code{};
   if (!response.is_object()) {
-    return {};
+    return { unmatched_400, {} };
   }
   if (const auto& name = response.find("name"); name != nullptr && name->is_string()) {
     std::string description;
@@ -131,9 +147,9 @@ extract_eventing_error_code(const tao::json::value& response)
     if (problem.name == "ERR_INVALID_CONFIG" || problem.name == "ERR_INTER_FUNCTION_RECURSION") {
       return { errc::common::invalid_argument, problem };
     }
-    return { errc::common::internal_server_failure, problem };
+    return { unmatched_400 ? unmatched_400 : errc::common::internal_server_failure, problem };
   }
-  return {};
+  return { unmatched_400, {} };
 }
 
 auto
@@ -215,6 +231,31 @@ translate_query_error_code(std::uint64_t error, const std::string& message, std:
   return extract_common_query_error_code(error, message);
 }
 
+auto
+extract_query_error_code(std::uint32_t status_code, const std::string& response_body)
+  -> std::error_code
+{
+  tao::json::value payload{};
+  try {
+    payload = utils::json::parse(response_body);
+  } catch (const tao::pegtl::parse_error&) {
+    return extract_common_error_code(status_code, response_body);
+  }
+  if (const auto* errors = payload.is_object() ? payload.find("errors") : nullptr;
+      errors != nullptr && errors->is_array() && !errors->get_array().empty()) {
+    const auto& first = errors->get_array().front();
+    if (const auto* code = first.is_object() ? first.find("code") : nullptr;
+        code != nullptr && code->is_integer()) {
+      if (auto ec = translate_query_error_code(code->as<std::uint64_t>(),
+                                               first.optional<std::string>("msg").value_or(""));
+          ec) {
+        return ec.value();
+      }
+    }
+  }
+  return extract_common_error_code(status_code, response_body);
+}
+
 auto
 translate_analytics_error_code(std::uint64_t error, const std::string& /* message */)
   -> std::optional<std::error_code>
@@ -229,6 +270,13 @@ translate_analytics_error_code(std::uint64_t error, const std::string& /* messag
     case 24006: /* Link [string] does not exist | Link [string] does not exist */
       return errc::analytics::link_not_found;
 
+    case 24000: /* RFC-58: ParsingFailure */
+      return errc::common::parsing_failure;
+
+    case 23000: /* RFC-58: TemporaryFailure */
+    case 23003: /* RFC-58: TemporaryFailure */
+      return errc::common::temporary_failure;
+
     case 23007: /* Job queue is full with [string] jobs */
       return errc::analytics::job_queue_full;
 
@@ -262,9 +310,15 @@ translate_analytics_error_code(std::uint64_t error, const std::string& /* messag
       if (error >= 24000 && error < 25000) {
         return errc::analytics::compilation_failure;
       }
+      if (error >= 20000 && error < 21000) {
+        return errc::common::authentication_failure;
+      }
+      if (error >= 25000 && error < 26000) {
+        return errc::common::internal_server_failure;
+      }
       break;
   }
-  return errc::common::internal_server_failure;
+  return {};
 }
 
 auto

data/ext/couchbase/core/operations/management/error_utils.hxx

@@ -23,7 +23,10 @@
 
 #include <tao/json/forward.hpp>
 
+#include <cstdint>
 #include <optional>
+#include <string>
+#include <system_error>
 
 namespace couchbase::core::operations::management
 {
@@ -35,16 +38,41 @@ 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>
-extract_eventing_error_code(const tao::json::value& response);
+extract_eventing_error_code(const tao::json::value& response, std::uint32_t status_code);
 
 std::optional<std::error_code>
 translate_query_error_code(std::uint64_t error,
                            const std::string& message,
                            std::uint64_t reason = 0);
 
+/**
+ * RFC-58: the first query error code in the body decides, as for a query statement. Only a code
+ * without a mapping of its own, or a body without one, falls back on the HTTP status.
+ */
+[[nodiscard]] std::error_code
+extract_query_error_code(std::uint32_t status_code, const std::string& response_body);
+
 std::optional<std::error_code>
 translate_analytics_error_code(std::uint64_t error, const std::string& message);
 
+/**
+ * RFC-58: the first analytics error code decides, through translate_analytics_error_code(). Only a
+ * code without a mapping of its own falls back on the HTTP status.
+ */
+template<typename Problems>
+[[nodiscard]] auto
+extract_analytics_error_code(std::uint32_t status_code,
+                             const Problems& errors,
+                             const std::string& response_body) -> std::error_code
+{
+  if (!errors.empty()) {
+    if (auto ec = translate_analytics_error_code(errors.front().code, errors.front().message); ec) {
+      return ec.value();
+    }
+  }
+  return extract_common_error_code(status_code, response_body);
+}
+
 std::optional<std::error_code>
 translate_search_error_code(std::uint32_t status_code, const std::string& response_body);
 

data/ext/couchbase/core/operations/management/eventing_deploy_function.cxx

@@ -30,7 +30,8 @@ eventing_deploy_function_request::encode_to(encoded_request_type& encoded,
                                             http_context& /* context */) const -> std::error_code
 {
   encoded.method = "POST";
-  encoded.path = fmt::format("/api/v1/functions/{}/deploy", name);
+  encoded.path =
+    fmt::format("/api/v1/functions/{}/deploy", utils::string_codec::v2::path_escape(name));
   if (bucket_name.has_value() && scope_name.has_value()) {
     encoded.path += fmt::format("?bucket={}&scope={}",
                                 utils::string_codec::v2::path_escape(bucket_name.value()),
@@ -47,6 +48,9 @@ eventing_deploy_function_request::make_response(error_context::http&& ctx,
   eventing_deploy_function_response response{ std::move(ctx) };
   if (!response.ctx.ec) {
     if (encoded.body.data().empty()) {
+      if (encoded.status_code == 400) {
+        response.ctx.ec = errc::common::invalid_argument;
+      }
       return response;
     }
     tao::json::value payload{};
@@ -56,10 +60,12 @@ eventing_deploy_function_request::make_response(error_context::http&& ctx,
       response.ctx.ec = errc::common::parsing_failure;
       return response;
     }
-    auto [ec, problem] = extract_eventing_error_code(payload);
+    auto [ec, problem] = extract_eventing_error_code(payload, encoded.status_code);
     if (ec) {
       response.ctx.ec = ec;
-      response.error.emplace(problem);
+      if (!problem.name.empty()) {
+        response.error.emplace(problem);
+      }
     }
   }
   return response;

data/ext/couchbase/core/operations/management/eventing_drop_function.cxx

@@ -30,7 +30,7 @@ eventing_drop_function_request::encode_to(encoded_request_type& encoded,
                                           http_context& /* context */) const -> std::error_code
 {
   encoded.method = "DELETE";
-  encoded.path = fmt::format("/api/v1/functions/{}", name);
+  encoded.path = fmt::format("/api/v1/functions/{}", utils::string_codec::v2::path_escape(name));
   if (bucket_name.has_value() && scope_name.has_value()) {
     encoded.path += fmt::format("?bucket={}&scope={}",
                                 utils::string_codec::v2::path_escape(bucket_name.value()),
@@ -47,6 +47,9 @@ eventing_drop_function_request::make_response(error_context::http&& ctx,
   eventing_drop_function_response response{ std::move(ctx) };
   if (!response.ctx.ec) {
     if (encoded.body.data().empty()) {
+      if (encoded.status_code == 400) {
+        response.ctx.ec = errc::common::invalid_argument;
+      }
       return response;
     }
     tao::json::value payload{};
@@ -56,10 +59,12 @@ eventing_drop_function_request::make_response(error_context::http&& ctx,
       response.ctx.ec = errc::common::parsing_failure;
       return response;
     }
-    auto [ec, problem] = extract_eventing_error_code(payload);
+    auto [ec, problem] = extract_eventing_error_code(payload, encoded.status_code);
     if (ec) {
       response.ctx.ec = ec;
-      response.error.emplace(problem);
+      if (!problem.name.empty()) {
+        response.error.emplace(problem);
+      }
       return response;
     }
   }

data/ext/couchbase/core/operations/management/eventing_get_all_functions.cxx

@@ -48,10 +48,12 @@ eventing_get_all_functions_request::make_response(error_context::http&& ctx,
       response.ctx.ec = errc::common::parsing_failure;
       return response;
     }
-    auto [ec, problem] = extract_eventing_error_code(payload);
+    auto [ec, problem] = extract_eventing_error_code(payload, encoded.status_code);
     if (ec) {
       response.ctx.ec = ec;
-      response.error.emplace(problem);
+      if (!problem.name.empty()) {
+        response.error.emplace(problem);
+      }
       return response;
     }
     if (!payload.is_array()) {

data/ext/couchbase/core/operations/management/eventing_get_function.cxx

@@ -31,7 +31,7 @@ eventing_get_function_request::encode_to(encoded_request_type& encoded,
                                          http_context& /* context */) const -> std::error_code
 {
   encoded.method = "GET";
-  encoded.path = fmt::format("/api/v1/functions/{}", name);
+  encoded.path = fmt::format("/api/v1/functions/{}", utils::string_codec::v2::path_escape(name));
   if (bucket_name.has_value() && scope_name.has_value()) {
     encoded.path += fmt::format("?bucket={}&scope={}",
                                 utils::string_codec::v2::path_escape(bucket_name.value()),
@@ -54,10 +54,12 @@ eventing_get_function_request::make_response(error_context::http&& ctx,
       response.ctx.ec = errc::common::parsing_failure;
       return response;
     }
-    auto [ec, problem] = extract_eventing_error_code(payload);
+    auto [ec, problem] = extract_eventing_error_code(payload, encoded.status_code);
     if (ec) {
       response.ctx.ec = ec;
-      response.error.emplace(problem);
+      if (!problem.name.empty()) {
+        response.error.emplace(problem);
+      }
       return response;
     }
     response.function = payload.as<couchbase::core::management::eventing::function>();

data/ext/couchbase/core/operations/management/eventing_get_status.cxx

@@ -48,10 +48,12 @@ eventing_get_status_request::make_response(error_context::http&& ctx,
       response.ctx.ec = errc::common::parsing_failure;
       return response;
     }
-    auto [ec, problem] = extract_eventing_error_code(payload);
+    auto [ec, problem] = extract_eventing_error_code(payload, encoded.status_code);
     if (ec) {
       response.ctx.ec = ec;
-      response.error.emplace(problem);
+      if (!problem.name.empty()) {
+        response.error.emplace(problem);
+      }
       return response;
     }
     response.status = payload.as<core::management::eventing::status>();

data/ext/couchbase/core/operations/management/eventing_pause_function.cxx

@@ -31,7 +31,8 @@ eventing_pause_function_request::encode_to(encoded_request_type& encoded,
                                            http_context& /* context */) const -> std::error_code
 {
   encoded.method = "POST";
-  encoded.path = fmt::format("/api/v1/functions/{}/pause", name);
+  encoded.path =
+    fmt::format("/api/v1/functions/{}/pause", utils::string_codec::v2::path_escape(name));
   if (bucket_name.has_value() && scope_name.has_value()) {
     encoded.path += fmt::format("?bucket={}&scope={}",
                                 utils::string_codec::v2::path_escape(bucket_name.value()),
@@ -48,6 +49,9 @@ eventing_pause_function_request::make_response(error_context::http&& ctx,
   eventing_pause_function_response response{ std::move(ctx) };
   if (!response.ctx.ec) {
     if (encoded.body.data().empty()) {
+      if (encoded.status_code == 400) {
+        response.ctx.ec = errc::common::invalid_argument;
+      }
       return response;
     }
     tao::json::value payload{};
@@ -57,10 +61,12 @@ eventing_pause_function_request::make_response(error_context::http&& ctx,
       response.ctx.ec = errc::common::parsing_failure;
       return response;
     }
-    auto [ec, problem] = extract_eventing_error_code(payload);
+    auto [ec, problem] = extract_eventing_error_code(payload, encoded.status_code);
     if (ec) {
       response.ctx.ec = ec;
-      response.error.emplace(problem);
+      if (!problem.name.empty()) {
+        response.error.emplace(problem);
+      }
     }
   }
   return response;

data/ext/couchbase/core/operations/management/eventing_resume_function.cxx

@@ -30,7 +30,8 @@ eventing_resume_function_request::encode_to(encoded_request_type& encoded,
                                             http_context& /* context */) const -> std::error_code
 {
   encoded.method = "POST";
-  encoded.path = fmt::format("/api/v1/functions/{}/resume", name);
+  encoded.path =
+    fmt::format("/api/v1/functions/{}/resume", utils::string_codec::v2::path_escape(name));
   if (bucket_name.has_value() && scope_name.has_value()) {
     encoded.path += fmt::format("?bucket={}&scope={}",
                                 utils::string_codec::v2::path_escape(bucket_name.value()),
@@ -47,6 +48,9 @@ eventing_resume_function_request::make_response(error_context::http&& ctx,
   eventing_resume_function_response response{ std::move(ctx) };
   if (!response.ctx.ec) {
     if (encoded.body.data().empty()) {
+      if (encoded.status_code == 400) {
+        response.ctx.ec = errc::common::invalid_argument;
+      }
       return response;
     }
     tao::json::value payload{};
@@ -56,10 +60,12 @@ eventing_resume_function_request::make_response(error_context::http&& ctx,
       response.ctx.ec = errc::common::parsing_failure;
       return response;
     }
-    auto [ec, problem] = extract_eventing_error_code(payload);
+    auto [ec, problem] = extract_eventing_error_code(payload, encoded.status_code);
     if (ec) {
       response.ctx.ec = ec;
-      response.error.emplace(problem);
+      if (!problem.name.empty()) {
+        response.error.emplace(problem);
+      }
     }
   }
   return response;

data/ext/couchbase/core/operations/management/eventing_undeploy_function.cxx

@@ -30,7 +30,8 @@ eventing_undeploy_function_request::encode_to(encoded_request_type& encoded,
                                               http_context& /* context */) const -> std::error_code
 {
   encoded.method = "POST";
-  encoded.path = fmt::format("/api/v1/functions/{}/undeploy", name);
+  encoded.path =
+    fmt::format("/api/v1/functions/{}/undeploy", utils::string_codec::v2::path_escape(name));
   if (bucket_name.has_value() && scope_name.has_value()) {
     encoded.path += fmt::format("?bucket={}&scope={}",
                                 utils::string_codec::v2::path_escape(bucket_name.value()),
@@ -47,6 +48,9 @@ eventing_undeploy_function_request::make_response(error_context::http&& ctx,
   eventing_undeploy_function_response response{ std::move(ctx) };
   if (!response.ctx.ec) {
     if (encoded.body.data().empty()) {
+      if (encoded.status_code == 400) {
+        response.ctx.ec = errc::common::invalid_argument;
+      }
       return response;
     }
     tao::json::value payload{};
@@ -56,10 +60,12 @@ eventing_undeploy_function_request::make_response(error_context::http&& ctx,
       response.ctx.ec = errc::common::parsing_failure;
       return response;
     }
-    auto [ec, problem] = extract_eventing_error_code(payload);
+    auto [ec, problem] = extract_eventing_error_code(payload, encoded.status_code);
     if (ec) {
       response.ctx.ec = ec;
-      response.error.emplace(problem);
+      if (!problem.name.empty()) {
+        response.error.emplace(problem);
+      }
     }
   }
   return response;

data/ext/couchbase/core/operations/management/eventing_upsert_function.cxx

@@ -332,7 +332,8 @@ eventing_upsert_function_request::encode_to(encoded_request_type& encoded,
 
   encoded.headers["content-type"] = "application/json";
   encoded.method = "POST";
-  encoded.path = fmt::format("/api/v1/functions/{}", function.name);
+  encoded.path =
+    fmt::format("/api/v1/functions/{}", utils::string_codec::v2::path_escape(function.name));
   if (bucket_name.has_value() && scope_name.has_value()) {
     encoded.path += fmt::format("?bucket={}&scope={}",
                                 utils::string_codec::v2::path_escape(bucket_name.value()),
@@ -350,6 +351,9 @@ eventing_upsert_function_request::make_response(error_context::http&& ctx,
   eventing_upsert_function_response response{ std::move(ctx) };
   if (!response.ctx.ec) {
     if (encoded.body.data().empty()) {
+      if (encoded.status_code == 400) {
+        response.ctx.ec = errc::common::invalid_argument;
+      }
       return response;
     }
     tao::json::value payload{};
@@ -359,10 +363,12 @@ eventing_upsert_function_request::make_response(error_context::http&& ctx,
       response.ctx.ec = errc::common::parsing_failure;
       return response;
     }
-    auto [ec, problem] = extract_eventing_error_code(payload);
+    auto [ec, problem] = extract_eventing_error_code(payload, encoded.status_code);
     if (ec) {
       response.ctx.ec = ec;
-      response.error.emplace(problem);
+      if (!problem.name.empty()) {
+        response.error.emplace(problem);
+      }
       return response;
     }
   }

data/ext/couchbase/core/operations/management/group_drop.cxx

@@ -17,6 +17,7 @@
 
 #include "group_drop.hxx"
 
+#include "core/utils/url_codec.hxx"
 #include "error_utils.hxx"
 
 #include <spdlog/fmt/bundled/core.h>
@@ -28,7 +29,8 @@ group_drop_request::encode_to(encoded_request_type& encoded,
                               http_context& /* context */) const -> std::error_code
 {
   encoded.method = "DELETE";
-  encoded.path = fmt::format("/settings/rbac/groups/{}", name);
+  encoded.path =
+    fmt::format("/settings/rbac/groups/{}", utils::string_codec::v2::path_escape(name));
   return {};
 }
 

data/ext/couchbase/core/operations/management/group_get.cxx

@@ -19,6 +19,7 @@
 
 #include "core/management/rbac_json.hxx"
 #include "core/utils/json.hxx"
+#include "core/utils/url_codec.hxx"
 #include "error_utils.hxx"
 
 #include <spdlog/fmt/bundled/core.h>
@@ -31,7 +32,8 @@ group_get_request::encode_to(encoded_request_type& encoded,
                              http_context& /* context */) const -> std::error_code
 {
   encoded.method = "GET";
-  encoded.path = fmt::format("/settings/rbac/groups/{}", name);
+  encoded.path =
+    fmt::format("/settings/rbac/groups/{}", utils::string_codec::v2::path_escape(name));
   encoded.headers["content-type"] = "application/x-www-form-urlencoded";
   return {};
 }

data/ext/couchbase/core/operations/management/group_upsert.cxx

@@ -31,35 +31,38 @@ group_upsert_request::encode_to(encoded_request_type& encoded,
                                 http_context& /* context */) const -> std::error_code
 {
   encoded.method = "PUT";
-  encoded.path = fmt::format("/settings/rbac/groups/{}", group.name);
+  encoded.path =
+    fmt::format("/settings/rbac/groups/{}", utils::string_codec::v2::path_escape(group.name));
   std::vector<std::string> params{};
   if (group.description) {
     params.push_back(
-      fmt::format("description={}", utils::string_codec::url_encode(group.description.value())));
+      fmt::format("description={}", utils::string_codec::form_encode(group.description.value())));
   }
   if (group.ldap_group_reference) {
     params.push_back(fmt::format(
-      "ldap_group_ref={}", utils::string_codec::url_encode(group.ldap_group_reference.value())));
+      "ldap_group_ref={}", utils::string_codec::form_encode(group.ldap_group_reference.value())));
   }
+  // Names go into the spec unescaped: the server does not percent-decode role parameters after
+  // form-decoding the body, so the spec is form-encoded exactly once, as a whole.
   std::vector<std::string> encoded_roles{};
   encoded_roles.reserve(group.roles.size());
   for (const auto& role : group.roles) {
     std::string spec = role.name;
     if (role.bucket) {
-      spec += fmt::format("[{}", utils::string_codec::v2::path_escape(role.bucket.value()));
+      spec += fmt::format("[{}", role.bucket.value());
       if (role.scope) {
-        spec += fmt::format(":{}", utils::string_codec::v2::path_escape(role.scope.value()));
+        spec += fmt::format(":{}", role.scope.value());
         if (role.collection) {
-          spec += fmt::format(":{}", utils::string_codec::v2::path_escape(role.collection.value()));
+          spec += fmt::format(":{}", role.collection.value());
         }
       }
-      spec += "]";
+      spec += ']';
     }
     encoded_roles.push_back(spec);
   }
   if (!encoded_roles.empty()) {
     const std::string concatenated = fmt::format("{}", utils::join_strings(encoded_roles, ","));
-    params.push_back(fmt::format("roles={}", utils::string_codec::url_encode(concatenated)));
+    params.push_back(fmt::format("roles={}", utils::string_codec::form_encode(concatenated)));
   }
   encoded.body = utils::join_strings(params, "&");
   encoded.headers["content-type"] = "application/x-www-form-urlencoded";

data/ext/couchbase/core/operations/management/query_index_build.cxx

@@ -81,14 +81,17 @@ query_index_build_request::make_response(error_context::http&& ctx,
       return response;
     }
     response.status = payload.at("status").get_string();
-    if (response.status != "success") {
+    // RFC-58: a 400 is a failure whatever status the body reports.
+    if (response.status != "success" || encoded.status_code == 400) {
       std::optional<std::error_code> common_ec{};
       for (const auto& entry : payload.at("errors").get_array()) {
         query_index_build_response::query_problem error;
         error.code = entry.at("code").get_unsigned();
         error.message = entry.at("msg").get_string();
         response.errors.emplace_back(error);
-        common_ec = management::extract_common_query_error_code(error.code, error.message);
+        if (!common_ec) {
+          common_ec = management::extract_common_query_error_code(error.code, error.message);
+        }
       }
 
       response.ctx.ec =

data/ext/couchbase/core/operations/management/query_index_create.cxx

@@ -104,7 +104,8 @@ query_index_create_request::make_response(error_context::http&& ctx,
     }
     response.status = payload.at("status").get_string();
 
-    if (response.status != "success") {
+    // RFC-58: a 400 is a failure whatever status the body reports.
+    if (response.status != "success" || encoded.status_code == 400) {
       bool index_already_exists = false;
       bool bucket_not_found = false;
       bool collection_not_found = false;
@@ -125,6 +126,9 @@ query_index_create_request::make_response(error_context::http&& ctx,
             if (error.message.find("Bucket Not Found") != std::string::npos) {
               bucket_not_found = true;
             }
+            if (!common_ec) {
+              common_ec = management::extract_common_query_error_code(error.code, error.message);
+            }
           } break;
 
           case 12003: /* IKey: "datastore.couchbase.keyspace_not_found" */
@@ -149,7 +153,9 @@ query_index_create_request::make_response(error_context::http&& ctx,
             break;
 
           default:
-            common_ec = management::extract_common_query_error_code(error.code, error.message);
+            if (!common_ec) {
+              common_ec = management::extract_common_query_error_code(error.code, error.message);
+            }
             break;
         }
         response.errors.emplace_back(error);
@@ -168,7 +174,7 @@ query_index_create_request::make_response(error_context::http&& ctx,
         response.ctx.ec = errc::common::authentication_failure;
       } else if (common_ec) {
         response.ctx.ec = common_ec.value();
-      } else if (!response.errors.empty()) {
+      } else {
         response.ctx.ec = extract_common_error_code(encoded.status_code, encoded.body.data());
       }
     }

data/ext/couchbase/core/operations/management/query_index_drop.cxx

@@ -73,7 +73,8 @@ query_index_drop_request::make_response(error_context::http&& ctx,
     }
     response.status = payload.at("status").get_string();
 
-    if (response.status != "success") {
+    // RFC-58: a 400 is a failure whatever status the body reports.
+    if (response.status != "success" || encoded.status_code == 400) {
       bool bucket_not_found = false;
       bool index_not_found = false;
       bool collection_not_found = false;
@@ -88,9 +89,13 @@ query_index_drop_request::make_response(error_context::http&& ctx,
           case 5000: /* IKey: "Internal Error" */
           {
             if (utils::contains_string(error.message, "index", true) &&
-                utils::contains_string(error.message, "not found", true)) {
+                (utils::contains_string(error.message, "not found", true) ||
+                 utils::contains_string(error.message, "does not exist", true))) {
               index_not_found = true;
             }
+            if (!common_ec) {
+              common_ec = management::extract_common_query_error_code(error.code, error.message);
+            }
           } break;
 
           case 12003: /* IKey: "datastore.couchbase.keyspace_not_found" */
@@ -117,7 +122,9 @@ query_index_drop_request::make_response(error_context::http&& ctx,
             break;
 
           default:
-            common_ec = management::extract_common_query_error_code(error.code, error.message);
+            if (!common_ec) {
+              common_ec = management::extract_common_query_error_code(error.code, error.message);
+            }
             break;
         }
         response.errors.emplace_back(error);
@@ -136,7 +143,7 @@ query_index_drop_request::make_response(error_context::http&& ctx,
         response.ctx.ec = errc::common::authentication_failure;
       } else if (common_ec) {
         response.ctx.ec = common_ec.value();
-      } else if (!response.errors.empty()) {
+      } else {
         response.ctx.ec = extract_common_error_code(encoded.status_code, encoded.body.data());
       }
     }

data/ext/couchbase/core/operations/management/query_index_get_all.cxx

@@ -80,7 +80,7 @@ query_index_get_all_request::make_response(couchbase::core::error_context::http&
   query_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());
+      response.ctx.ec = extract_query_error_code(encoded.status_code, encoded.body.data());
       return response;
     }
     tao::json::value payload{};

data/ext/couchbase/core/operations/management/query_index_get_all_deferred.cxx

@@ -82,7 +82,7 @@ query_index_get_all_deferred_request::make_response(couchbase::core::error_conte
   query_index_get_all_deferred_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());
+      response.ctx.ec = extract_query_error_code(encoded.status_code, encoded.body.data());
       return response;
     }
     tao::json::value payload{};