couchbase 3.8.1 → 3.9.0

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

@@ -30,104 +30,101 @@ namespace couchbase::core::operations::management
 {
 
 auto
-bucket_create_request::encode_to(encoded_request_type& encoded,
-                                 http_context& /* context */) const -> std::error_code
+bucket_create_request::encode_to(encoded_request_type& encoded, http_context& /* context */) const
+  -> std::error_code
 {
   encoded.method = "POST";
   encoded.path = "/pools/default/buckets";
 
   encoded.headers["content-type"] = "application/x-www-form-urlencoded";
-  encoded.body.append(fmt::format("name={}", utils::string_codec::form_encode(bucket.name)));
+
+  std::map<std::string, std::string> values{};
+  values["name"] = bucket.name;
   switch (bucket.bucket_type) {
     case couchbase::core::management::cluster::bucket_type::couchbase:
-      encoded.body.append("&bucketType=couchbase");
+      values["bucketType"] = "couchbase";
       break;
     case couchbase::core::management::cluster::bucket_type::memcached:
-      encoded.body.append("&bucketType=memcached");
+      values["bucketType"] = "memcached";
       break;
     case couchbase::core::management::cluster::bucket_type::ephemeral:
-      encoded.body.append("&bucketType=ephemeral");
+      values["bucketType"] = "ephemeral";
       break;
     case couchbase::core::management::cluster::bucket_type::unknown:
       break;
   }
   if (bucket.ram_quota_mb == 0) {
-    encoded.body.append(fmt::format(
-      "&ramQuotaMB={}", 100)); // If not explicitly set, set to prior default value of 100
+    values["ramQuotaMB"] = "100"; // If not explicitly set, set to prior default value of 100
   } else {
-    encoded.body.append(fmt::format("&ramQuotaMB={}", bucket.ram_quota_mb));
+    values["ramQuotaMB"] = std::to_string(bucket.ram_quota_mb);
   }
 
   if (bucket.bucket_type != couchbase::core::management::cluster::bucket_type::memcached &&
       bucket.num_replicas.has_value()) {
-    encoded.body.append(fmt::format("&replicaNumber={}", bucket.num_replicas.value()));
+    values["replicaNumber"] = std::to_string(bucket.num_replicas.value());
   }
   if (bucket.max_expiry.has_value()) {
-    encoded.body.append(fmt::format("&maxTTL={}", bucket.max_expiry.value()));
+    values["maxTTL"] = std::to_string(bucket.max_expiry.value());
   }
   if (bucket.bucket_type != couchbase::core::management::cluster::bucket_type::ephemeral &&
       bucket.replica_indexes.has_value()) {
-    encoded.body.append(
-      fmt::format("&replicaIndex={}", bucket.replica_indexes.value() ? "1" : "0"));
+    values["replicaIndex"] = bucket.replica_indexes.value() ? "1" : "0";
   }
   if (bucket.history_retention_collection_default.has_value()) {
-    encoded.body.append(
-      fmt::format("&historyRetentionCollectionDefault={}",
-                  bucket.history_retention_collection_default.value() ? "true" : "false"));
+    values["historyRetentionCollectionDefault"] =
+      bucket.history_retention_collection_default.value() ? "true" : "false";
   }
   if (bucket.history_retention_bytes.has_value()) {
-    encoded.body.append(
-      fmt::format("&historyRetentionBytes={}", bucket.history_retention_bytes.value()));
+    values["historyRetentionBytes"] = std::to_string(bucket.history_retention_bytes.value());
   }
   if (bucket.history_retention_duration.has_value()) {
-    encoded.body.append(
-      fmt::format("&historyRetentionSeconds={}", bucket.history_retention_duration.value()));
+    values["historyRetentionSeconds"] = std::to_string(bucket.history_retention_duration.value());
   }
   if (bucket.flush_enabled.has_value()) {
-    encoded.body.append(fmt::format("&flushEnabled={}", bucket.flush_enabled.value() ? "1" : "0"));
+    values["flushEnabled"] = bucket.flush_enabled.value() ? "1" : "0";
   }
   if (bucket.num_vbuckets.has_value()) {
-    encoded.body.append(fmt::format("&numVBuckets={}", bucket.num_vbuckets.value()));
+    values["numVBuckets"] = std::to_string(bucket.num_vbuckets.value());
   }
 
   switch (bucket.eviction_policy) {
     case couchbase::core::management::cluster::bucket_eviction_policy::full:
-      encoded.body.append("&evictionPolicy=fullEviction");
+      values["evictionPolicy"] = "fullEviction";
       break;
     case couchbase::core::management::cluster::bucket_eviction_policy::value_only:
-      encoded.body.append("&evictionPolicy=valueOnly");
+      values["evictionPolicy"] = "valueOnly";
       break;
     case couchbase::core::management::cluster::bucket_eviction_policy::no_eviction:
-      encoded.body.append("&evictionPolicy=noEviction");
+      values["evictionPolicy"] = "noEviction";
       break;
     case couchbase::core::management::cluster::bucket_eviction_policy::not_recently_used:
-      encoded.body.append("&evictionPolicy=nruEviction");
+      values["evictionPolicy"] = "nruEviction";
       break;
     case couchbase::core::management::cluster::bucket_eviction_policy::unknown:
       break;
   }
   switch (bucket.compression_mode) {
     case couchbase::core::management::cluster::bucket_compression::off:
-      encoded.body.append("&compressionMode=off");
+      values["compressionMode"] = "off";
       break;
     case couchbase::core::management::cluster::bucket_compression::active:
-      encoded.body.append("&compressionMode=active");
+      values["compressionMode"] = "active";
       break;
     case couchbase::core::management::cluster::bucket_compression::passive:
-      encoded.body.append("&compressionMode=passive");
+      values["compressionMode"] = "passive";
       break;
     case couchbase::core::management::cluster::bucket_compression::unknown:
       break;
   }
   switch (bucket.conflict_resolution_type) {
     case couchbase::core::management::cluster::bucket_conflict_resolution::timestamp:
-      encoded.body.append("&conflictResolutionType=lww");
+      values["conflictResolutionType"] = "lww";
       break;
     case couchbase::core::management::cluster::bucket_conflict_resolution::sequence_number:
-      encoded.body.append("&conflictResolutionType=seqno");
+      values["conflictResolutionType"] = "seqno";
       break;
     case couchbase::core::management::cluster::bucket_conflict_resolution::custom:
-      encoded.body.append("&conflictResolutionType=custom");
+      values["conflictResolutionType"] = "custom";
       break;
     case couchbase::core::management::cluster::bucket_conflict_resolution::unknown:
       break;
@@ -135,16 +132,16 @@ bucket_create_request::encode_to(encoded_request_type& encoded,
   if (bucket.minimum_durability_level.has_value()) {
     switch (bucket.minimum_durability_level.value()) {
       case durability_level::none:
-        encoded.body.append("&durabilityMinLevel=none");
+        values["durabilityMinLevel"] = "none";
         break;
       case durability_level::majority:
-        encoded.body.append("&durabilityMinLevel=majority");
+        values["durabilityMinLevel"] = "majority";
         break;
       case durability_level::majority_and_persist_to_active:
-        encoded.body.append("&durabilityMinLevel=majorityAndPersistActive");
+        values["durabilityMinLevel"] = "majorityAndPersistActive";
         break;
       case durability_level::persist_to_majority:
-        encoded.body.append("&durabilityMinLevel=persistToMajority");
+        values["durabilityMinLevel"] = "persistToMajority";
         break;
     }
   }
@@ -152,12 +149,14 @@ bucket_create_request::encode_to(encoded_request_type& encoded,
     case couchbase::core::management::cluster::bucket_storage_backend::unknown:
       break;
     case couchbase::core::management::cluster::bucket_storage_backend::couchstore:
-      encoded.body.append("&storageBackend=couchstore");
+      values["storageBackend"] = "couchstore";
       break;
     case couchbase::core::management::cluster::bucket_storage_backend::magma:
-      encoded.body.append("&storageBackend=magma");
+      values["storageBackend"] = "magma";
       break;
   }
+
+  encoded.body = utils::string_codec::v2::form_encode(values);
   return {};
 }
 auto

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

@@ -30,8 +30,8 @@
 namespace couchbase::core::operations::management
 {
 auto
-bucket_update_request::encode_to(encoded_request_type& encoded,
-                                 http_context& /* context */) const -> std::error_code
+bucket_update_request::encode_to(encoded_request_type& encoded, http_context& /* context */) const
+  -> std::error_code
 {
   encoded.method = "POST";
   encoded.path =
@@ -39,65 +39,61 @@ bucket_update_request::encode_to(encoded_request_type& encoded,
 
   encoded.headers["content-type"] = "application/x-www-form-urlencoded";
 
+  std::map<std::string, std::string> values{};
   if (bucket.ram_quota_mb > 0) {
-    encoded.body.append(fmt::format("&ramQuotaMB={}", bucket.ram_quota_mb));
+    values["ramQuotaMB"] = std::to_string(bucket.ram_quota_mb);
   }
   if (bucket.num_replicas.has_value()) {
-    encoded.body.append(fmt::format("&replicaNumber={}", bucket.num_replicas.value()));
+    values["replicaNumber"] = std::to_string(bucket.num_replicas.value());
   }
-
   if (bucket.max_expiry.has_value()) {
-    encoded.body.append(fmt::format("&maxTTL={}", bucket.max_expiry.value()));
+    values["maxTTL"] = std::to_string(bucket.max_expiry.value());
   }
   if (bucket.history_retention_collection_default.has_value()) {
-    encoded.body.append(
-      fmt::format("&historyRetentionCollectionDefault={}",
-                  bucket.history_retention_collection_default.value() ? "true" : "false"));
+    values["historyRetentionCollectionDefault"] =
+      bucket.history_retention_collection_default.value() ? "true" : "false";
   }
   if (bucket.history_retention_bytes.has_value()) {
-    encoded.body.append(
-      fmt::format("&historyRetentionBytes={}", bucket.history_retention_bytes.value()));
+    values["historyRetentionBytes"] = std::to_string(bucket.history_retention_bytes.value());
   }
   if (bucket.history_retention_duration.has_value()) {
-    encoded.body.append(
-      fmt::format("&historyRetentionSeconds={}", bucket.history_retention_duration.value()));
+    values["historyRetentionSeconds"] = std::to_string(bucket.history_retention_duration.value());
   }
   if (bucket.replica_indexes.has_value()) {
-    encoded.body.append(
-      fmt::format("&replicaIndex={}", bucket.replica_indexes.value() ? "1" : "0"));
+    values["replicaIndex"] = bucket.replica_indexes.value() ? "1" : "0";
   }
   if (bucket.flush_enabled.has_value()) {
-    encoded.body.append(fmt::format("&flushEnabled={}", bucket.flush_enabled.value() ? "1" : "0"));
+    values["flushEnabled"] = bucket.flush_enabled.value() ? "1" : "0";
   }
   if (bucket.num_vbuckets.has_value()) {
-    encoded.body.append(fmt::format("&numVBuckets={}", bucket.num_vbuckets.value()));
+    values["numVBuckets"] = std::to_string(bucket.num_vbuckets.value());
   }
 
   switch (bucket.eviction_policy) {
     case couchbase::core::management::cluster::bucket_eviction_policy::full:
-      encoded.body.append("&evictionPolicy=fullEviction");
+      values["evictionPolicy"] = "fullEviction";
       break;
     case couchbase::core::management::cluster::bucket_eviction_policy::value_only:
-      encoded.body.append("&evictionPolicy=valueOnly");
+      values["evictionPolicy"] = "valueOnly";
       break;
     case couchbase::core::management::cluster::bucket_eviction_policy::no_eviction:
-      encoded.body.append("&evictionPolicy=noEviction");
+      values["evictionPolicy"] = "noEviction";
       break;
     case couchbase::core::management::cluster::bucket_eviction_policy::not_recently_used:
-      encoded.body.append("&evictionPolicy=nruEviction");
+      values["evictionPolicy"] = "nruEviction";
       break;
     case couchbase::core::management::cluster::bucket_eviction_policy::unknown:
       break;
   }
   switch (bucket.compression_mode) {
     case couchbase::core::management::cluster::bucket_compression::off:
-      encoded.body.append("&compressionMode=off");
+      values["compressionMode"] = "off";
       break;
     case couchbase::core::management::cluster::bucket_compression::active:
-      encoded.body.append("&compressionMode=active");
+      values["compressionMode"] = "active";
       break;
     case couchbase::core::management::cluster::bucket_compression::passive:
-      encoded.body.append("&compressionMode=passive");
+      values["compressionMode"] = "passive";
       break;
     case couchbase::core::management::cluster::bucket_compression::unknown:
       break;
@@ -105,19 +101,21 @@ bucket_update_request::encode_to(encoded_request_type& encoded,
   if (bucket.minimum_durability_level) {
     switch (bucket.minimum_durability_level.value()) {
       case durability_level::none:
-        encoded.body.append("&durabilityMinLevel=none");
+        values["durabilityMinLevel"] = "none";
         break;
       case durability_level::majority:
-        encoded.body.append("&durabilityMinLevel=majority");
+        values["durabilityMinLevel"] = "majority";
         break;
       case durability_level::majority_and_persist_to_active:
-        encoded.body.append("&durabilityMinLevel=majorityAndPersistActive");
+        values["durabilityMinLevel"] = "majorityAndPersistActive";
         break;
       case durability_level::persist_to_majority:
-        encoded.body.append("&durabilityMinLevel=persistToMajority");
+        values["durabilityMinLevel"] = "persistToMajority";
         break;
     }
   }
+
+  encoded.body = utils::string_codec::v2::form_encode(values);
   return {};
 }
 

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 ");

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;