couchbase 3.8.0 → 3.8.2

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/collection_create.cxx

@@ -24,13 +24,11 @@
 #include <spdlog/fmt/bundled/core.h>
 #include <tao/json/value.hpp>
 
-#include <regex>
-
 namespace couchbase::core::operations::management
 {
 auto
-collection_create_request::encode_to(encoded_request_type& encoded,
-                                     http_context& /*context*/) const -> std::error_code
+collection_create_request::encode_to(encoded_request_type& encoded, http_context& /*context*/) const
+  -> std::error_code
 {
   encoded.method = "POST";
   encoded.path = fmt::format("/pools/default/buckets/{}/scopes/{}/collections",
@@ -58,18 +56,20 @@ collection_create_request::make_response(error_context::http&& ctx,
 {
   collection_create_response response{ std::move(ctx) };
   if (!response.ctx.ec) {
-    switch (encoded.status_code) {
+    switch (const auto& body = encoded.body.data(); encoded.status_code) {
       case 400: {
-        const std::regex collection_exists("Collection with name .+ already exists");
-        if (std::regex_search(encoded.body.data(), collection_exists)) {
+        const auto prefix_pos = body.find("Collection with name ");
+        if (prefix_pos != std::string_view::npos &&
+            body.find(" already exists", prefix_pos) != std::string_view::npos) {
           response.ctx.ec = errc::management::collection_exists;
         } else {
           response.ctx.ec = errc::common::invalid_argument;
         }
       } break;
       case 404: {
-        const std::regex scope_not_found("Scope with name .+ is not found");
-        if (std::regex_search(encoded.body.data(), scope_not_found)) {
+        const auto prefix_pos = body.find("Scope with name ");
+        if (prefix_pos != std::string_view::npos &&
+            body.find(" is not found", prefix_pos) != std::string_view::npos) {
           response.ctx.ec = errc::common::scope_not_found;
         } else {
           response.ctx.ec = errc::common::bucket_not_found;
@@ -78,7 +78,7 @@ collection_create_request::make_response(error_context::http&& ctx,
       case 200: {
         tao::json::value payload{};
         try {
-          payload = utils::json::parse(encoded.body.data());
+          payload = utils::json::parse(body);
         } catch (const tao::pegtl::parse_error&) {
           response.ctx.ec = errc::common::parsing_failure;
           return response;
@@ -86,7 +86,7 @@ collection_create_request::make_response(error_context::http&& ctx,
         response.uid = std::stoull(payload.at("uid").get_string(), nullptr, 16);
       } break;
       default:
-        response.ctx.ec = extract_common_error_code(encoded.status_code, encoded.body.data());
+        response.ctx.ec = extract_common_error_code(encoded.status_code, body);
         break;
     }
   }

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

@@ -24,13 +24,11 @@
 #include <spdlog/fmt/bundled/core.h>
 #include <tao/json/value.hpp>
 
-#include <regex>
-
 namespace couchbase::core::operations::management
 {
 auto
-collection_drop_request::encode_to(encoded_request_type& encoded,
-                                   http_context& /* context */) const -> std::error_code
+collection_drop_request::encode_to(encoded_request_type& encoded, http_context& /* context */) const
+  -> std::error_code
 {
   encoded.method = "DELETE";
   encoded.path = fmt::format("/pools/default/buckets/{}/scopes/{}/collections/{}",
@@ -47,16 +45,18 @@ collection_drop_request::make_response(error_context::http&& ctx,
 {
   collection_drop_response response{ std::move(ctx) };
   if (!response.ctx.ec) {
-    switch (encoded.status_code) {
+    switch (const auto& body = encoded.body.data(); encoded.status_code) {
       case 400:
         response.ctx.ec = errc::common::unsupported_operation;
         break;
       case 404: {
-        const std::regex scope_not_found("Scope with name .+ is not found");
-        const std::regex collection_not_found("Collection with name .+ is not found");
-        if (std::regex_search(encoded.body.data(), collection_not_found)) {
+        const auto collection_prefix_pos = body.find("Collection with name ");
+        const auto scope_prefix_pos = body.find("Scope with name ");
+        if (collection_prefix_pos != std::string_view::npos &&
+            body.find(" is not found", collection_prefix_pos) != std::string_view::npos) {
           response.ctx.ec = errc::common::collection_not_found;
-        } else if (std::regex_search(encoded.body.data(), scope_not_found)) {
+        } else if (scope_prefix_pos != std::string_view::npos &&
+                   body.find(" is not found", scope_prefix_pos) != std::string_view::npos) {
           response.ctx.ec = errc::common::scope_not_found;
         } else {
           response.ctx.ec = errc::common::bucket_not_found;
@@ -65,7 +65,7 @@ collection_drop_request::make_response(error_context::http&& ctx,
       case 200: {
         tao::json::value payload{};
         try {
-          payload = utils::json::parse(encoded.body.data());
+          payload = utils::json::parse(body);
         } catch (const tao::pegtl::parse_error&) {
           response.ctx.ec = errc::common::parsing_failure;
           return response;
@@ -73,7 +73,7 @@ collection_drop_request::make_response(error_context::http&& ctx,
         response.uid = std::stoull(payload.at("uid").get_string(), nullptr, 16);
       } break;
       default:
-        response.ctx.ec = extract_common_error_code(encoded.status_code, encoded.body.data());
+        response.ctx.ec = extract_common_error_code(encoded.status_code, body);
         break;
     }
   }

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

@@ -24,13 +24,11 @@
 #include <spdlog/fmt/bundled/core.h>
 #include <tao/json/value.hpp>
 
-#include <regex>
-
 namespace couchbase::core::operations::management
 {
 auto
-collection_update_request::encode_to(encoded_request_type& encoded,
-                                     http_context& /*context*/) const -> std::error_code
+collection_update_request::encode_to(encoded_request_type& encoded, http_context& /*context*/) const
+  -> std::error_code
 {
   encoded.method = "PATCH";
   encoded.path = fmt::format("/pools/default/buckets/{}/scopes/{}/collections/{}",
@@ -60,16 +58,18 @@ collection_update_request::make_response(error_context::http&& ctx,
 {
   collection_update_response response{ std::move(ctx) };
   if (!response.ctx.ec) {
-    switch (encoded.status_code) {
+    switch (const auto& body = encoded.body.data(); encoded.status_code) {
       case 400: {
         response.ctx.ec = errc::common::invalid_argument;
       } break;
       case 404: {
-        const std::regex scope_not_found("Scope with name .+ is not found");
-        const std::regex collection_not_found("Collection with name .+ is not found");
-        if (std::regex_search(encoded.body.data(), collection_not_found)) {
+        const auto collection_prefix_pos = body.find("Collection with name ");
+        const auto scope_prefix_pos = body.find("Scope with name ");
+        if (collection_prefix_pos != std::string_view::npos &&
+            body.find(" is not found", collection_prefix_pos) != std::string_view::npos) {
           response.ctx.ec = errc::common::collection_not_found;
-        } else if (std::regex_search(encoded.body.data(), scope_not_found)) {
+        } else if (scope_prefix_pos != std::string_view::npos &&
+                   body.find(" is not found", scope_prefix_pos) != std::string_view::npos) {
           response.ctx.ec = errc::common::scope_not_found;
         } else {
           response.ctx.ec = errc::common::bucket_not_found;
@@ -78,7 +78,7 @@ collection_update_request::make_response(error_context::http&& ctx,
       case 200: {
         tao::json::value payload{};
         try {
-          payload = utils::json::parse(encoded.body.data());
+          payload = utils::json::parse(body);
         } catch (const tao::pegtl::parse_error&) {
           response.ctx.ec = errc::common::parsing_failure;
           return response;
@@ -86,7 +86,7 @@ collection_update_request::make_response(error_context::http&& ctx,
         response.uid = std::stoull(payload.at("uid").get_string(), nullptr, 16);
       } break;
       default:
-        response.ctx.ec = extract_common_error_code(encoded.status_code, encoded.body.data());
+        response.ctx.ec = extract_common_error_code(encoded.status_code, body);
         break;
     }
   }

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

@@ -16,12 +16,11 @@
  */
 
 #include "error_utils.hxx"
+#include "core/utils/contains_string.hxx"
 #include "core/utils/json.hxx"
 
 #include <tao/json/value.hpp>
 
-#include <regex>
-
 namespace couchbase::core::operations::management
 {
 
@@ -143,12 +142,16 @@ translate_query_error_code(std::uint64_t error, const std::string& message, std:
 {
   switch (error) {
     case 5000: /* IKey: "Internal Error" */
-      if (std::regex_search(message, std::regex{ ".*[iI]ndex .*already exist.*" })) {
+      if (utils::contains_string(message, "index", true) &&
+          utils::contains_string(message, "already exist", true)) {
         return errc::common::index_exists;
-      } else if (message.find("Index does not exist") != std::string::npos ||
-                 std::regex_search(message, std::regex{ ".*[iI]ndex .*[nN]ot [fF]ound.*" })) {
+      }
+      if (utils::contains_string(message, "Index does not exist") ||
+          (utils::contains_string(message, "index", true) &&
+           utils::contains_string(message, "not found", true))) {
         return errc::common::index_not_found;
-      } else if (message.find("Bucket Not Found") != std::string::npos) {
+      }
+      if (message.find("Bucket Not Found") != std::string::npos) {
         return errc::common::bucket_not_found;
       }
       break;

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

@@ -17,6 +17,7 @@
 
 #include "query_index_create.hxx"
 
+#include "core/utils/contains_string.hxx"
 #include "core/utils/json.hxx"
 #include "core/utils/keyspace.hxx"
 #include "error_utils.hxx"
@@ -24,8 +25,6 @@
 #include <spdlog/fmt/bundled/core.h>
 #include <tao/json/value.hpp>
 
-#include <regex>
-
 namespace couchbase::core::operations::management
 {
 auto
@@ -118,13 +117,15 @@ query_index_create_request::make_response(error_context::http&& ctx,
         error.message = entry.at("msg").get_string();
         switch (error.code) {
           case 5000: /* IKey: "Internal Error" */
-            if (std::regex_search(error.message, std::regex{ ".*[iI]ndex .*already exist.*" })) {
+          {
+            if (utils::contains_string(error.message, "index", true) &&
+                utils::contains_string(error.message, "already exist", true)) {
               index_already_exists = true;
             }
             if (error.message.find("Bucket Not Found") != std::string::npos) {
               bucket_not_found = true;
             }
-            break;
+          } break;
 
           case 12003: /* IKey: "datastore.couchbase.keyspace_not_found" */
             if (error.message.find("missing_collection") != std::string::npos) {

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

@@ -17,6 +17,7 @@
 
 #include "query_index_drop.hxx"
 
+#include "core/utils/contains_string.hxx"
 #include "core/utils/json.hxx"
 #include "core/utils/keyspace.hxx"
 #include "error_utils.hxx"
@@ -24,13 +25,11 @@
 #include <spdlog/fmt/bundled/core.h>
 #include <tao/json/value.hpp>
 
-#include <regex>
-
 namespace couchbase::core::operations::management
 {
 auto
-query_index_drop_request::encode_to(encoded_request_type& encoded,
-                                    http_context& /*context*/) const -> std::error_code
+query_index_drop_request::encode_to(encoded_request_type& encoded, http_context& /*context*/) const
+  -> std::error_code
 {
   if (!utils::check_query_management_request(*this)) {
     return errc::common::invalid_argument;
@@ -87,10 +86,12 @@ query_index_drop_request::make_response(error_context::http&& ctx,
         error.message = entry.at("msg").get_string();
         switch (error.code) {
           case 5000: /* IKey: "Internal Error" */
-            if (std::regex_search(error.message, std::regex{ ".*[iI]ndex .*[nN]ot [fF]ound.*" })) {
+          {
+            if (utils::contains_string(error.message, "index", true) &&
+                utils::contains_string(error.message, "not found", true)) {
               index_not_found = true;
             }
-            break;
+          } break;
 
           case 12003: /* IKey: "datastore.couchbase.keyspace_not_found" */
             if (error.message.find("missing_collection") != std::string::npos) {

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

@@ -24,13 +24,11 @@
 #include <spdlog/fmt/bundled/core.h>
 #include <tao/json/value.hpp>
 
-#include <regex>
-
 namespace couchbase::core::operations::management
 {
 auto
-scope_create_request::encode_to(encoded_request_type& encoded,
-                                http_context& /* context */) const -> std::error_code
+scope_create_request::encode_to(encoded_request_type& encoded, http_context& /* context */) const
+  -> std::error_code
 {
   encoded.method = "POST";
   encoded.path = fmt::format("/pools/default/buckets/{}/scopes",
@@ -41,18 +39,19 @@ scope_create_request::encode_to(encoded_request_type& encoded,
 }
 
 auto
-scope_create_request::make_response(error_context::http&& ctx, const encoded_response_type& encoded)
-  const -> scope_create_response
+scope_create_request::make_response(error_context::http&& ctx,
+                                    const encoded_response_type& encoded) const
+  -> scope_create_response
 {
   scope_create_response response{ std::move(ctx) };
   if (!response.ctx.ec) {
-    switch (encoded.status_code) {
+    switch (const auto& body = encoded.body.data(); encoded.status_code) {
       case 400: {
-        const std::regex scope_exists("Scope with name .+ already exists");
-        if (std::regex_search(encoded.body.data(), scope_exists)) {
+        const auto prefix_pos = body.find("Scope with name ");
+        if (prefix_pos != std::string_view::npos &&
+            body.find(" already exists", prefix_pos) != std::string_view::npos) {
           response.ctx.ec = errc::management::scope_exists;
-        } else if (encoded.body.data().find("Not allowed on this version of cluster") !=
-                   std::string::npos) {
+        } else if (body.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;
@@ -64,7 +63,7 @@ scope_create_request::make_response(error_context::http&& ctx, const encoded_res
       case 200: {
         tao::json::value payload{};
         try {
-          payload = utils::json::parse(encoded.body.data());
+          payload = utils::json::parse(body);
         } catch (const tao::pegtl::parse_error&) {
           response.ctx.ec = errc::common::parsing_failure;
           return response;
@@ -72,7 +71,7 @@ scope_create_request::make_response(error_context::http&& ctx, const encoded_res
         response.uid = std::stoull(payload.at("uid").get_string(), nullptr, 16);
       } break;
       default:
-        response.ctx.ec = extract_common_error_code(encoded.status_code, encoded.body.data());
+        response.ctx.ec = extract_common_error_code(encoded.status_code, body);
         break;
     }
   }