couchbase 3.8.1 → 3.9.0

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{};

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

@@ -45,7 +45,11 @@ scope_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 prefix_pos = body.find("Scope with name ");

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

@@ -46,7 +46,12 @@ scope_get_all_request::make_response(error_context::http&& ctx,
   if (!response.ctx.ec) {
     switch (encoded.status_code) {
       case 400:
-        response.ctx.ec = errc::common::unsupported_operation;
+        if (encoded.body.data().find("Not allowed on this version of cluster") !=
+            std::string::npos) {
+          response.ctx.ec = errc::common::unsupported_operation;
+        } else {
+          response.ctx.ec = errc::common::invalid_argument;
+        }
         break;
       case 404:
         response.ctx.ec = errc::common::bucket_not_found;

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

@@ -16,6 +16,7 @@
  */
 
 #include "search_get_stats.hxx"
+#include "error_utils.hxx"
 
 #include <couchbase/error_codes.hxx>
 
@@ -37,6 +38,15 @@ search_get_stats_request::make_response(error_context::http&& ctx,
 {
   search_get_stats_response response{ std::move(ctx) };
   if (!response.ctx.ec) {
+    if (encoded.status_code == 401 || encoded.status_code == 403) {
+      // RFC-58: Search reports a 401 or 403 as an authentication failure.
+      response.ctx.ec = errc::common::authentication_failure;
+      return response;
+    }
+    if (encoded.status_code != 200) {
+      response.ctx.ec = extract_common_error_code(encoded.status_code, encoded.body.data());
+      return response;
+    }
     response.stats = encoded.body.data();
   }
   return response;

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

@@ -41,9 +41,10 @@ search_index_analyze_document_request::encode_to(encoded_request_type& encoded,
     encoded.path = fmt::format("/api/bucket/{}/scope/{}/index/{}/analyzeDoc",
                                utils::string_codec::v2::path_escape(bucket_name.value()),
                                utils::string_codec::v2::path_escape(scope_name.value()),
-                               index_name);
+                               utils::string_codec::v2::path_escape(index_name));
   } else {
-    encoded.path = fmt::format("/api/index/{}/analyzeDoc", index_name);
+    encoded.path =
+      fmt::format("/api/index/{}/analyzeDoc", utils::string_codec::v2::path_escape(index_name));
   }
   encoded.body = encoded_document;
   return {};

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

@@ -38,11 +38,12 @@ search_index_control_ingest_request::encode_to(encoded_request_type& encoded,
     encoded.path = fmt::format("/api/bucket/{}/scope/{}/index/{}/ingestControl/{}",
                                utils::string_codec::v2::path_escape(bucket_name.value()),
                                utils::string_codec::v2::path_escape(scope_name.value()),
-                               index_name,
+                               utils::string_codec::v2::path_escape(index_name),
                                pause ? "pause" : "resume");
   } else {
-    encoded.path =
-      fmt::format("/api/index/{}/ingestControl/{}", index_name, pause ? "pause" : "resume");
+    encoded.path = fmt::format("/api/index/{}/ingestControl/{}",
+                               utils::string_codec::v2::path_escape(index_name),
+                               pause ? "pause" : "resume");
   }
   return {};
 }

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

@@ -39,11 +39,12 @@ search_index_control_plan_freeze_request::encode_to(encoded_request_type& encode
     encoded.path = fmt::format("/api/bucket/{}/scope/{}/index/{}/planFreezeControl/{}",
                                utils::string_codec::v2::path_escape(bucket_name.value()),
                                utils::string_codec::v2::path_escape(scope_name.value()),
-                               index_name,
+                               utils::string_codec::v2::path_escape(index_name),
                                freeze ? "freeze" : "unfreeze");
   } else {
-    encoded.path =
-      fmt::format("/api/index/{}/planFreezeControl/{}", index_name, freeze ? "freeze" : "unfreeze");
+    encoded.path = fmt::format("/api/index/{}/planFreezeControl/{}",
+                               utils::string_codec::v2::path_escape(index_name),
+                               freeze ? "freeze" : "unfreeze");
   }
   return {};
 }

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

@@ -38,11 +38,12 @@ search_index_control_query_request::encode_to(encoded_request_type& encoded,
     encoded.path = fmt::format("/api/bucket/{}/scope/{}/index/{}/queryControl/{}",
                                utils::string_codec::v2::path_escape(bucket_name.value()),
                                utils::string_codec::v2::path_escape(scope_name.value()),
-                               index_name,
+                               utils::string_codec::v2::path_escape(index_name),
                                allow ? "allow" : "disallow");
   } else {
-    encoded.path =
-      fmt::format("/api/index/{}/queryControl/{}", index_name, allow ? "allow" : "disallow");
+    encoded.path = fmt::format("/api/index/{}/queryControl/{}",
+                               utils::string_codec::v2::path_escape(index_name),
+                               allow ? "allow" : "disallow");
   }
   return {};
 }

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

@@ -38,9 +38,9 @@ search_index_drop_request::encode_to(encoded_request_type& encoded,
     encoded.path = fmt::format("/api/bucket/{}/scope/{}/index/{}",
                                utils::string_codec::v2::path_escape(bucket_name.value()),
                                utils::string_codec::v2::path_escape(scope_name.value()),
-                               index_name);
+                               utils::string_codec::v2::path_escape(index_name));
   } else {
-    encoded.path = fmt::format("/api/index/{}", index_name);
+    encoded.path = fmt::format("/api/index/{}", utils::string_codec::v2::path_escape(index_name));
   }
   return {};
 }

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

@@ -39,9 +39,9 @@ search_index_get_request::encode_to(encoded_request_type& encoded,
     encoded.path = fmt::format("/api/bucket/{}/scope/{}/index/{}",
                                utils::string_codec::v2::path_escape(bucket_name.value()),
                                utils::string_codec::v2::path_escape(scope_name.value()),
-                               index_name);
+                               utils::string_codec::v2::path_escape(index_name));
   } else {
-    encoded.path = fmt::format("/api/index/{}", index_name);
+    encoded.path = fmt::format("/api/index/{}", utils::string_codec::v2::path_escape(index_name));
   }
   return {};
 }

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

@@ -36,9 +36,10 @@ search_index_get_documents_count_request::encode_to(encoded_request_type& encode
     encoded.path = fmt::format("/api/bucket/{}/scope/{}/index/{}/count",
                                utils::string_codec::v2::path_escape(bucket_name.value()),
                                utils::string_codec::v2::path_escape(scope_name.value()),
-                               index_name);
+                               utils::string_codec::v2::path_escape(index_name));
   } else {
-    encoded.path = fmt::format("/api/index/{}/count", index_name);
+    encoded.path =
+      fmt::format("/api/index/{}/count", utils::string_codec::v2::path_escape(index_name));
   }
   return {};
 }

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

@@ -18,6 +18,7 @@
 #include "search_index_get_stats.hxx"
 
 #include "core/utils/json.hxx"
+#include "core/utils/url_codec.hxx"
 #include "error_utils.hxx"
 
 #include <spdlog/fmt/bundled/core.h>
@@ -33,7 +34,8 @@ search_index_get_stats_request::encode_to(encoded_request_type& encoded,
     return errc::common::invalid_argument;
   }
   encoded.method = "GET";
-  encoded.path = fmt::format("/api/stats/index/{}", index_name);
+  encoded.path =
+    fmt::format("/api/stats/index/{}", utils::string_codec::v2::path_escape(index_name));
   return {};
 }
 

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

@@ -41,9 +41,9 @@ search_index_upsert_request::encode_to(encoded_request_type& encoded,
     encoded.path = fmt::format("/api/bucket/{}/scope/{}/index/{}",
                                utils::string_codec::v2::path_escape(bucket_name.value()),
                                utils::string_codec::v2::path_escape(scope_name.value()),
-                               index.name);
+                               utils::string_codec::v2::path_escape(index.name));
   } else {
-    encoded.path = fmt::format("/api/index/{}", index.name);
+    encoded.path = fmt::format("/api/index/{}", utils::string_codec::v2::path_escape(index.name));
   }
   tao::json::value body{
     { "name", index.name },

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

@@ -18,6 +18,7 @@
 #include "user_drop.hxx"
 
 #include "core/management/rbac_fmt.hxx"
+#include "core/utils/url_codec.hxx"
 #include "error_utils.hxx"
 
 namespace couchbase::core::operations::management
@@ -27,7 +28,8 @@ user_drop_request::encode_to(encoded_request_type& encoded,
                              http_context& /* context */) const -> std::error_code
 {
   encoded.method = "DELETE";
-  encoded.path = fmt::format("/settings/rbac/users/{}/{}", domain, username);
+  encoded.path = fmt::format(
+    "/settings/rbac/users/{}/{}", domain, utils::string_codec::v2::path_escape(username));
   return {};
 }
 

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

@@ -20,6 +20,7 @@
 #include "core/management/rbac_fmt.hxx"
 #include "core/management/rbac_json.hxx"
 #include "core/utils/json.hxx"
+#include "core/utils/url_codec.hxx"
 #include "error_utils.hxx"
 
 #include <tao/json/value.hpp>
@@ -31,7 +32,8 @@ user_get_request::encode_to(encoded_request_type& encoded,
                             http_context& /* context */) const -> std::error_code
 {
   encoded.method = "GET";
-  encoded.path = fmt::format("/settings/rbac/users/{}/{}", domain, username);
+  encoded.path = fmt::format(
+    "/settings/rbac/users/{}/{}", domain, utils::string_codec::v2::path_escape(username));
   encoded.headers["content-type"] = "application/x-www-form-urlencoded";
   return {};
 }

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

@@ -32,39 +32,42 @@ user_upsert_request::encode_to(encoded_request_type& encoded,
                                http_context& /* context */) const -> std::error_code
 {
   encoded.method = "PUT";
-  encoded.path = fmt::format("/settings/rbac/users/{}/{}", domain, user.username);
+  encoded.path = fmt::format(
+    "/settings/rbac/users/{}/{}", domain, utils::string_codec::v2::path_escape(user.username));
   std::vector<std::string> params{};
   if (user.display_name) {
     params.push_back(
-      fmt::format("name={}", utils::string_codec::url_encode(user.display_name.value())));
+      fmt::format("name={}", utils::string_codec::form_encode(user.display_name.value())));
   }
   if (user.password) {
     params.push_back(
-      fmt::format("password={}", utils::string_codec::url_encode(user.password.value())));
+      fmt::format("password={}", utils::string_codec::form_encode(user.password.value())));
   }
   if (!user.groups.empty()) {
     const std::string encoded_groups = utils::join_strings(user.groups, ",");
-    params.push_back(fmt::format("groups={}", utils::string_codec::url_encode(encoded_groups)));
+    params.push_back(fmt::format("groups={}", utils::string_codec::form_encode(encoded_groups)));
   }
+  // 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(user.roles.size());
   for (const auto& role : user.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 = 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/view_index_drop.cxx

@@ -33,7 +33,7 @@ view_index_drop_request::encode_to(encoded_request_type& encoded,
   encoded.path = fmt::format("/{}/_design/{}{}",
                              utils::string_codec::v2::path_escape(bucket_name),
                              ns == design_document_namespace::development ? "dev_" : "",
-                             document_name);
+                             utils::string_codec::v2::path_escape(document_name));
   return {};
 }
 

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

@@ -34,7 +34,7 @@ view_index_get_request::encode_to(encoded_request_type& encoded,
   encoded.path = fmt::format("/{}/_design/{}{}",
                              utils::string_codec::v2::path_escape(bucket_name),
                              ns == design_document_namespace::development ? "dev_" : "",
-                             document_name);
+                             utils::string_codec::v2::path_escape(document_name));
   return {};
 }
 

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

@@ -48,7 +48,7 @@ view_index_upsert_request::encode_to(encoded_request_type& encoded,
   encoded.path = fmt::format("/{}/_design/{}{}",
                              utils::string_codec::v2::path_escape(bucket_name),
                              document.ns == design_document_namespace::development ? "dev_" : "",
-                             document.name);
+                             utils::string_codec::v2::path_escape(document.name));
   encoded.body = utils::json::generate(body);
   return {};
 }