couchbase 3.8.2 → 3.9.0

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

@@ -30,16 +30,22 @@ auto
 analytics_dataset_create_request::encode_to(encoded_request_type& encoded,
                                             http_context& /* context */) const -> std::error_code
 {
-  std::string where_clause = condition ? fmt::format("WHERE {}", *condition) : "";
-  std::string if_not_exists_clause = ignore_if_exists ? "IF NOT EXISTS" : "";
+  if (!utils::analytics::all_quotable({ dataverse_name, dataset_name, bucket_name })) {
+    return errc::common::invalid_argument;
+  }
+
+  // Note: condition is a raw SQL++ predicate expression (e.g., "type = 'airline'")
+  // provided by the caller and is appended verbatim to the WHERE clause.
+  std::string where_clause = condition ? fmt::format(" WHERE {}", *condition) : "";
+  std::string if_not_exists_clause = ignore_if_exists ? " IF NOT EXISTS" : "";
 
   const tao::json::value body{
     { "statement",
-      fmt::format("CREATE DATASET {} {}.`{}` ON `{}` {}",
+      fmt::format("CREATE DATASET{} {}.{} ON {}{}",
                   if_not_exists_clause,
-                  utils::analytics::uncompound_name(dataverse_name),
-                  dataset_name,
-                  bucket_name,
+                  utils::analytics::quote_dataverse_name(dataverse_name),
+                  utils::analytics::quote_identifier(dataset_name),
+                  utils::analytics::quote_identifier(bucket_name),
                   where_clause) },
   };
   encoded.headers["content-type"] = "application/json";
@@ -64,7 +70,7 @@ analytics_dataset_create_request::make_response(error_context::http&& ctx,
       return response;
     }
     response.status = payload.optional<std::string>("status").value_or("unknown");
-    if (response.status != "success") {
+    if (response.status != "success" || encoded.status_code == 400) {
       bool dataset_exists = false;
       bool link_not_found = false;
 
@@ -92,7 +98,8 @@ analytics_dataset_create_request::make_response(error_context::http&& ctx,
       } else if (link_not_found) {
         response.ctx.ec = errc::analytics::link_not_found;
       } else {
-        response.ctx.ec = extract_common_error_code(encoded.status_code, encoded.body.data());
+        response.ctx.ec =
+          extract_analytics_error_code(encoded.status_code, response.errors, encoded.body.data());
       }
     }
   }

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

@@ -46,6 +46,10 @@ struct analytics_dataset_create_request {
   std::string dataset_name;
   std::string bucket_name;
 
+  /**
+   * Optional SQL++ filter predicate expression (e.g., "type = 'airline'").
+   * Must be a valid, trusted SQL++ predicate expression provided by the caller.
+   */
   std::optional<std::string> condition{};
   std::optional<std::string> client_context_id{};
   std::optional<std::chrono::milliseconds> timeout{};

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

@@ -30,13 +30,17 @@ auto
 analytics_dataset_drop_request::encode_to(encoded_request_type& encoded,
                                           http_context& /* context */) const -> std::error_code
 {
-  std::string if_exists_clause = ignore_if_does_not_exist ? "IF EXISTS" : "";
+  if (!utils::analytics::all_quotable({ dataverse_name, dataset_name })) {
+    return errc::common::invalid_argument;
+  }
+
+  std::string if_exists_clause = ignore_if_does_not_exist ? " IF EXISTS" : "";
 
   const tao::json::value body{
     { "statement",
-      fmt::format("DROP DATASET {}.`{}` {}",
-                  utils::analytics::uncompound_name(dataverse_name),
-                  dataset_name,
+      fmt::format("DROP DATASET {}.{}{}",
+                  utils::analytics::quote_dataverse_name(dataverse_name),
+                  utils::analytics::quote_identifier(dataset_name),
                   if_exists_clause) },
   };
   encoded.headers["content-type"] = "application/json";
@@ -62,7 +66,7 @@ analytics_dataset_drop_request::make_response(error_context::http&& ctx,
     }
     response.status = payload.optional<std::string>("status").value_or("unknown");
 
-    if (response.status != "success") {
+    if (response.status != "success" || encoded.status_code == 400) {
       bool dataset_does_not_exist = false;
 
       if (auto* errors = payload.find("errors"); errors != nullptr && errors->is_array()) {
@@ -84,7 +88,8 @@ analytics_dataset_drop_request::make_response(error_context::http&& ctx,
       if (dataset_does_not_exist) {
         response.ctx.ec = errc::analytics::dataset_not_found;
       } else {
-        response.ctx.ec = extract_common_error_code(encoded.status_code, encoded.body.data());
+        response.ctx.ec =
+          extract_analytics_error_code(encoded.status_code, response.errors, encoded.body.data());
       }
     }
   }

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

@@ -55,7 +55,7 @@ analytics_dataset_get_all_request::make_response(error_context::http&& ctx,
       return response;
     }
     response.status = payload.optional<std::string>("status").value_or("unknown");
-    if (response.status != "success") {
+    if (response.status != "success" || encoded.status_code == 400) {
       if (const auto* errors = payload.find("errors"); errors != nullptr && errors->is_array()) {
         for (const auto& error : errors->get_array()) {
           const analytics_problem err{
@@ -65,7 +65,8 @@ analytics_dataset_get_all_request::make_response(error_context::http&& ctx,
           response.errors.emplace_back(err);
         }
       }
-      response.ctx.ec = extract_common_error_code(encoded.status_code, encoded.body.data());
+      response.ctx.ec =
+        extract_analytics_error_code(encoded.status_code, response.errors, encoded.body.data());
       return response;
     }
     if (auto* results = payload.find("results"); results != nullptr && results->is_array()) {

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

@@ -30,12 +30,16 @@ auto
 analytics_dataverse_create_request::encode_to(encoded_request_type& encoded,
                                               http_context& /* context */) const -> std::error_code
 {
-  std::string if_not_exists_clause = ignore_if_exists ? "IF NOT EXISTS" : "";
+  if (!utils::analytics::all_quotable({ dataverse_name })) {
+    return errc::common::invalid_argument;
+  }
+
+  std::string if_not_exists_clause = ignore_if_exists ? " IF NOT EXISTS" : "";
 
   const tao::json::value body{
     { "statement",
-      fmt::format("CREATE DATAVERSE {} {}",
-                  utils::analytics::uncompound_name(dataverse_name),
+      fmt::format("CREATE DATAVERSE {}{}",
+                  utils::analytics::quote_dataverse_name(dataverse_name),
                   if_not_exists_clause) },
   };
   encoded.headers["content-type"] = "application/json";
@@ -61,7 +65,7 @@ analytics_dataverse_create_request::make_response(error_context::http&& ctx,
     }
     response.status = payload.optional<std::string>("status").value_or("unknown");
 
-    if (response.status != "success") {
+    if (response.status != "success" || encoded.status_code == 400) {
       bool dataverse_exists = false;
 
       if (auto* errors = payload.find("errors"); errors != nullptr && errors->is_array()) {
@@ -83,7 +87,8 @@ analytics_dataverse_create_request::make_response(error_context::http&& ctx,
       if (dataverse_exists) {
         response.ctx.ec = errc::analytics::dataverse_exists;
       } else {
-        response.ctx.ec = extract_common_error_code(encoded.status_code, encoded.body.data());
+        response.ctx.ec =
+          extract_analytics_error_code(encoded.status_code, response.errors, encoded.body.data());
       }
     }
   }

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

@@ -30,12 +30,16 @@ auto
 analytics_dataverse_drop_request::encode_to(encoded_request_type& encoded,
                                             http_context& /* context */) const -> std::error_code
 {
-  std::string if_exists_clause = ignore_if_does_not_exist ? "IF EXISTS" : "";
+  if (!utils::analytics::all_quotable({ dataverse_name })) {
+    return errc::common::invalid_argument;
+  }
+
+  std::string if_exists_clause = ignore_if_does_not_exist ? " IF EXISTS" : "";
 
   const tao::json::value body{
     { "statement",
-      fmt::format("DROP DATAVERSE {} {}",
-                  utils::analytics::uncompound_name(dataverse_name),
+      fmt::format("DROP DATAVERSE {}{}",
+                  utils::analytics::quote_dataverse_name(dataverse_name),
                   if_exists_clause) },
   };
   encoded.headers["content-type"] = "application/json";
@@ -61,7 +65,7 @@ analytics_dataverse_drop_request::make_response(error_context::http&& ctx,
     }
     response.status = payload.optional<std::string>("status").value_or("unknown");
 
-    if (response.status != "success") {
+    if (response.status != "success" || encoded.status_code == 400) {
       bool dataverse_does_not_exist = false;
 
       if (auto* errors = payload.find("errors"); errors != nullptr && errors->is_array()) {
@@ -83,7 +87,8 @@ analytics_dataverse_drop_request::make_response(error_context::http&& ctx,
       if (dataverse_does_not_exist) {
         response.ctx.ec = errc::analytics::dataverse_not_found;
       } else {
-        response.ctx.ec = extract_common_error_code(encoded.status_code, encoded.body.data());
+        response.ctx.ec =
+          extract_analytics_error_code(encoded.status_code, response.errors, encoded.body.data());
       }
     }
   }

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

@@ -70,7 +70,8 @@ analytics_get_pending_mutations_request::make_response(error_context::http&& ctx
         response.errors.emplace_back(err);
       }
     }
-    response.ctx.ec = extract_common_error_code(encoded.status_code, encoded.body.data());
+    response.ctx.ec =
+      extract_analytics_error_code(encoded.status_code, response.errors, encoded.body.data());
   }
   return response;
 }

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

@@ -22,6 +22,9 @@
 #include "core/utils/name_codec.hxx"
 #include "error_utils.hxx"
 
+#include <algorithm>
+
+#include <spdlog/fmt/bundled/core.h>
 #include <tao/json/value.hpp>
 
 namespace couchbase::core::operations::management
@@ -30,20 +33,41 @@ auto
 analytics_index_create_request::encode_to(encoded_request_type& encoded,
                                           http_context& /* context */) const -> std::error_code
 {
-  std::string if_not_exists_clause = ignore_if_exists ? "IF NOT EXISTS" : "";
+  if (!utils::analytics::all_quotable({ dataverse_name, dataset_name, index_name })) {
+    return errc::common::invalid_argument;
+  }
+
+  std::string if_not_exists_clause = ignore_if_exists ? " IF NOT EXISTS" : "";
   std::vector<std::string> field_specs;
   field_specs.reserve(fields.size());
   for (const auto& [field_name, field_type] : fields) {
-    field_specs.emplace_back(fmt::format("{}:{}", field_name, field_type));
+    if (!utils::analytics::all_quotable({ field_name })) {
+      return errc::common::invalid_argument;
+    }
+    // The field type is the one value in this statement that is interpolated without being quoted,
+    // so it is validated instead of encoded, and validating means naming the set that is accepted:
+    // ASCII alphanumeric, which covers every type the service will index on and admits nothing
+    // structural. The grammar would in fact accept the type quoted, like the names above; a
+    // whitelist is preferred because it turns a bad type into a clear invalid_argument here rather
+    // than an opaque server error. It is written out rather than delegated to std::isalnum to keep
+    // it independent of the host locale. Names carry no equivalent check, because quoting already
+    // makes their content inert, and rejecting an unusable one is left to the server.
+    if (field_type.empty() || !std::all_of(field_type.begin(), field_type.end(), [](char c) {
+          return (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z') || (c >= '0' && c <= '9');
+        })) {
+      return errc::common::invalid_argument;
+    }
+    field_specs.emplace_back(
+      fmt::format("{}:{}", utils::analytics::quote_field_path(field_name), field_type));
   }
 
   const tao::json::value body{
     { "statement",
-      fmt::format("CREATE INDEX `{}` {} ON {}.`{}` ({})",
-                  index_name,
+      fmt::format("CREATE INDEX {}{} ON {}.{} ({})",
+                  utils::analytics::quote_identifier(index_name),
                   if_not_exists_clause,
-                  utils::analytics::uncompound_name(dataverse_name),
-                  dataset_name,
+                  utils::analytics::quote_dataverse_name(dataverse_name),
+                  utils::analytics::quote_identifier(dataset_name),
                   utils::join_strings(field_specs, ",")) },
   };
   encoded.headers["content-type"] = "application/json";
@@ -69,7 +93,7 @@ analytics_index_create_request::make_response(error_context::http&& ctx,
     }
     response.status = payload.optional<std::string>("status").value_or("unknown");
 
-    if (response.status != "success") {
+    if (response.status != "success" || encoded.status_code == 400) {
       bool index_exists = false;
       bool dataset_not_found = false;
       bool link_not_found = false;
@@ -103,7 +127,8 @@ analytics_index_create_request::make_response(error_context::http&& ctx,
       } else if (link_not_found) {
         response.ctx.ec = errc::analytics::link_not_found;
       } else {
-        response.ctx.ec = extract_common_error_code(encoded.status_code, encoded.body.data());
+        response.ctx.ec =
+          extract_analytics_error_code(encoded.status_code, response.errors, encoded.body.data());
       }
     }
   }

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

@@ -30,14 +30,18 @@ auto
 analytics_index_drop_request::encode_to(encoded_request_type& encoded,
                                         http_context& /* context */) const -> std::error_code
 {
-  std::string if_exists_clause = ignore_if_does_not_exist ? "IF EXISTS" : "";
+  if (!utils::analytics::all_quotable({ dataverse_name, dataset_name, index_name })) {
+    return errc::common::invalid_argument;
+  }
+
+  std::string if_exists_clause = ignore_if_does_not_exist ? " IF EXISTS" : "";
 
   const tao::json::value body{
     { "statement",
-      fmt::format("DROP INDEX {}.`{}`.`{}` {}",
-                  utils::analytics::uncompound_name(dataverse_name),
-                  dataset_name,
-                  index_name,
+      fmt::format("DROP INDEX {}.{}.{}{}",
+                  utils::analytics::quote_dataverse_name(dataverse_name),
+                  utils::analytics::quote_identifier(dataset_name),
+                  utils::analytics::quote_identifier(index_name),
                   if_exists_clause) },
   };
   encoded.headers["content-type"] = "application/json";
@@ -63,7 +67,7 @@ analytics_index_drop_request::make_response(error_context::http&& ctx,
     }
     response.status = payload.optional<std::string>("status").value_or("unknown");
 
-    if (response.status != "success") {
+    if (response.status != "success" || encoded.status_code == 400) {
       bool index_does_not_exist = false;
       bool dataset_not_found = false;
 
@@ -91,7 +95,8 @@ analytics_index_drop_request::make_response(error_context::http&& ctx,
       } else if (dataset_not_found) {
         response.ctx.ec = errc::analytics::dataset_not_found;
       } else {
-        response.ctx.ec = extract_common_error_code(encoded.status_code, encoded.body.data());
+        response.ctx.ec =
+          extract_analytics_error_code(encoded.status_code, response.errors, encoded.body.data());
       }
     }
   }

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

@@ -55,7 +55,7 @@ analytics_index_get_all_request::make_response(error_context::http&& ctx,
       return response;
     }
     response.status = payload.optional<std::string>("status").value_or("unknown");
-    if (response.status == "success") {
+    if (response.status == "success" && encoded.status_code != 400) {
       if (auto* results = payload.find("results"); results != nullptr && results->is_array()) {
         for (const auto& res : results->get_array()) {
           couchbase::core::management::analytics::index idx;
@@ -76,7 +76,8 @@ analytics_index_get_all_request::make_response(error_context::http&& ctx,
           response.errors.emplace_back(err);
         }
       }
-      response.ctx.ec = extract_common_error_code(encoded.status_code, encoded.body.data());
+      response.ctx.ec =
+        extract_analytics_error_code(encoded.status_code, response.errors, encoded.body.data());
     }
   }
   return response;

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

@@ -30,13 +30,17 @@ auto
 analytics_link_connect_request::encode_to(encoded_request_type& encoded,
                                           http_context& /* context */) const -> std::error_code
 {
-  std::string with_clause = force ? "WITH {\"force\": true}" : "";
+  if (!utils::analytics::all_quotable({ dataverse_name, link_name })) {
+    return errc::common::invalid_argument;
+  }
+
+  std::string with_clause = force ? " WITH {\"force\": true}" : "";
 
   const tao::json::value body{
     { "statement",
-      fmt::format("CONNECT LINK {}.`{}` {}",
-                  utils::analytics::uncompound_name(dataverse_name),
-                  link_name,
+      fmt::format("CONNECT LINK {}.{}{}",
+                  utils::analytics::quote_dataverse_name(dataverse_name),
+                  utils::analytics::quote_identifier(link_name),
                   with_clause) },
   };
   encoded.headers["content-type"] = "application/json";
@@ -62,7 +66,7 @@ analytics_link_connect_request::make_response(error_context::http&& ctx,
     }
     response.status = payload.optional<std::string>("status").value_or("unknown");
 
-    if (response.status != "success") {
+    if (response.status != "success" || encoded.status_code == 400) {
       bool link_not_found = false;
 
       if (auto* errors = payload.find("errors"); errors != nullptr && errors->is_array()) {
@@ -84,7 +88,8 @@ analytics_link_connect_request::make_response(error_context::http&& ctx,
       if (link_not_found) {
         response.ctx.ec = errc::analytics::link_not_found;
       } else {
-        response.ctx.ec = extract_common_error_code(encoded.status_code, encoded.body.data());
+        response.ctx.ec =
+          extract_analytics_error_code(encoded.status_code, response.errors, encoded.body.data());
       }
     }
   }

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

@@ -18,7 +18,6 @@
 #include "analytics_link_create.hxx"
 
 #include "core/utils/json.hxx"
-#include "core/utils/name_codec.hxx"
 #include "error_utils.hxx"
 
 #include <tao/json/value.hpp>
@@ -50,7 +49,7 @@ make_analytics_link_create_response(error_context::http&& ctx, const io::http_re
     }
     if (payload.is_object()) {
       response.status = payload.optional<std::string>("status").value_or("unknown");
-      if (response.status != "success") {
+      if (response.status != "success" || encoded.status_code == 400) {
         if (auto* errors = payload.find("errors"); errors != nullptr && errors->is_array()) {
           for (const auto& error : errors->get_array()) {
             const management::analytics_link_create_response::problem err{
@@ -81,7 +80,8 @@ make_analytics_link_create_response(error_context::http&& ctx, const io::http_re
     } else if (link_exists) {
       response.ctx.ec = errc::analytics::link_exists;
     } else {
-      response.ctx.ec = extract_common_error_code(encoded.status_code, encoded.body.data());
+      response.ctx.ec =
+        extract_analytics_error_code(encoded.status_code, response.errors, encoded.body.data());
     }
   }
   return response;

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

@@ -30,10 +30,15 @@ auto
 analytics_link_disconnect_request::encode_to(encoded_request_type& encoded,
                                              http_context& /* context */) const -> std::error_code
 {
+  if (!utils::analytics::all_quotable({ dataverse_name, link_name })) {
+    return errc::common::invalid_argument;
+  }
+
   const tao::json::value body{
     { "statement",
-      fmt::format(
-        "DISCONNECT LINK {}.`{}`", utils::analytics::uncompound_name(dataverse_name), link_name) },
+      fmt::format("DISCONNECT LINK {}.{}",
+                  utils::analytics::quote_dataverse_name(dataverse_name),
+                  utils::analytics::quote_identifier(link_name)) },
   };
   encoded.headers["content-type"] = "application/json";
   encoded.method = "POST";
@@ -58,7 +63,7 @@ analytics_link_disconnect_request::make_response(error_context::http&& ctx,
     }
     response.status = payload.optional<std::string>("status").value_or("unknown");
 
-    if (response.status != "success") {
+    if (response.status != "success" || encoded.status_code == 400) {
       bool link_not_found = false;
 
       if (auto* errors = payload.find("errors"); errors != nullptr && errors->is_array()) {
@@ -80,7 +85,8 @@ analytics_link_disconnect_request::make_response(error_context::http&& ctx,
       if (link_not_found) {
         response.ctx.ec = errc::analytics::link_not_found;
       } else {
-        response.ctx.ec = extract_common_error_code(encoded.status_code, encoded.body.data());
+        response.ctx.ec =
+          extract_analytics_error_code(encoded.status_code, response.errors, encoded.body.data());
       }
     }
   }

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

@@ -41,8 +41,9 @@ analytics_link_drop_request::encode_to(encoded_request_type& encoded,
     encoded.body = utils::string_codec::v2::form_encode(values);
     encoded.path = "/analytics/link";
   } else {
-    encoded.path = fmt::format(
-      "/analytics/link/{}/{}", utils::string_codec::v2::path_escape(dataverse_name), link_name);
+    encoded.path = fmt::format("/analytics/link/{}/{}",
+                               utils::string_codec::v2::path_escape(dataverse_name),
+                               utils::string_codec::v2::path_escape(link_name));
   }
   return {};
 }
@@ -72,7 +73,7 @@ analytics_link_drop_request::make_response(error_context::http&& ctx,
     }
     if (payload.is_object()) {
       response.status = payload.optional<std::string>("status").value_or("unknown");
-      if (response.status != "success") {
+      if (response.status != "success" || encoded.status_code == 400) {
         if (auto* errors = payload.find("errors"); errors != nullptr && errors->is_array()) {
           for (const auto& error : errors->get_array()) {
             const analytics_link_drop_response::problem err{
@@ -103,7 +104,8 @@ analytics_link_drop_request::make_response(error_context::http&& ctx,
     } else if (link_not_found) {
       response.ctx.ec = errc::analytics::link_not_found;
     } else {
-      response.ctx.ec = extract_common_error_code(encoded.status_code, encoded.body.data());
+      response.ctx.ec =
+        extract_analytics_error_code(encoded.status_code, response.errors, encoded.body.data());
     }
   }
   return response;

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

@@ -60,7 +60,7 @@ analytics_link_get_all_request::encode_to(encoded_request_type& encoded,
       } else {
         encoded.path = fmt::format("/analytics/link/{}/{}",
                                    utils::string_codec::v2::path_escape(dataverse_name.value()),
-                                   link_name.value());
+                                   utils::string_codec::v2::path_escape(link_name.value()));
       }
     }
   } else {
@@ -97,7 +97,7 @@ analytics_link_get_all_request::make_response(error_context::http&& ctx,
     }
     if (payload.is_object()) {
       response.status = payload.optional<std::string>("status").value_or("unknown");
-      if (response.status != "success") {
+      if (response.status != "success" || encoded.status_code == 400) {
         if (auto* errors = payload.find("errors"); errors != nullptr && errors->is_array()) {
           for (const auto& error : errors->get_array()) {
             const analytics_link_get_all_response::problem err{
@@ -141,7 +141,8 @@ analytics_link_get_all_request::make_response(error_context::http&& ctx,
     } else if (link_not_found) {
       response.ctx.ec = errc::analytics::link_not_found;
     } else if (response.ctx.http_status != 200) {
-      response.ctx.ec = extract_common_error_code(encoded.status_code, encoded.body.data());
+      response.ctx.ec =
+        extract_analytics_error_code(encoded.status_code, response.errors, encoded.body.data());
     }
   }
   return response;

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

@@ -18,7 +18,6 @@
 #include "analytics_link_replace.hxx"
 
 #include "core/utils/json.hxx"
-#include "core/utils/name_codec.hxx"
 #include "error_utils.hxx"
 
 #include <tao/json/value.hpp>
@@ -50,7 +49,7 @@ make_analytics_link_replace_response(error_context::http&& ctx, const io::http_r
     }
     if (payload.is_object()) {
       response.status = payload.optional<std::string>("status").value_or("unknown");
-      if (response.status != "success") {
+      if (response.status != "success" || encoded.status_code == 400) {
         if (auto* errors = payload.find("errors"); errors != nullptr && errors->is_array()) {
           for (const auto& error : errors->get_array()) {
             const management::analytics_link_replace_response::problem err{
@@ -81,7 +80,8 @@ make_analytics_link_replace_response(error_context::http&& ctx, const io::http_r
     } else if (link_not_found) {
       response.ctx.ec = errc::analytics::link_not_found;
     } else {
-      response.ctx.ec = extract_common_error_code(encoded.status_code, encoded.body.data());
+      response.ctx.ec =
+        extract_analytics_error_code(encoded.status_code, response.errors, encoded.body.data());
     }
   }
   return response;

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

@@ -33,7 +33,7 @@ endpoint_from_analytics_link(const analytics_link_type& link) -> std::string
   if (std::count(link.dataverse.begin(), link.dataverse.end(), '/') > 0) {
     return fmt::format("/analytics/link/{}/{}",
                        utils::string_codec::v2::path_escape(link.dataverse),
-                       link.link_name);
+                       utils::string_codec::v2::path_escape(link.link_name));
   }
   return "/analytics/link";
 }

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

@@ -49,6 +49,8 @@ change_password_request::make_response(error_context::http&& ctx,
         if (encoded.body.data().find("Not allowed on this version of cluster") !=
             std::string::npos) {
           response.ctx.ec = errc::common::feature_not_available;
+        } else {
+          response.ctx.ec = errc::common::invalid_argument;
         }
         break;
       default:

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

@@ -47,7 +47,11 @@ collection_drop_request::make_response(error_context::http&& ctx,
   if (!response.ctx.ec) {
     switch (const auto& body = encoded.body.data(); encoded.status_code) {
       case 400:
-        response.ctx.ec = errc::common::unsupported_operation;
+        if (body.find("Not allowed on this version of cluster") != std::string_view::npos) {
+          response.ctx.ec = errc::common::unsupported_operation;
+        } else {
+          response.ctx.ec = errc::common::invalid_argument;
+        }
         break;
       case 404: {
         const auto collection_prefix_pos = body.find("Collection with name ");