couchbase 3.5.1 → 3.5.2

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

@@ -23,79 +23,83 @@
 namespace couchbase::core::operations::management
 {
 std::error_code
-query_index_get_all_deferred_request::encode_to(encoded_request_type& encoded, couchbase::core::http_context& /* context */) const
+query_index_get_all_deferred_request::encode_to(encoded_request_type& encoded,
+                                                couchbase::core::http_context& /* context */) const
 {
 
-    // essentially same as query_index_get_all_request::encode_to, except for the state condition.   If you
-    // change this, you probably need to change that as well.
-    std::string bucket_cond = "bucket_id = $bucket_name";
-    std::string scope_cond = "(" + bucket_cond + " AND scope_id = $scope_name)";
-    std::string collection_cond = "(" + scope_cond + " AND keyspace_id = $collection_name)";
+  // essentially same as query_index_get_all_request::encode_to, except for the state condition. If
+  // you change this, you probably need to change that as well.
+  std::string bucket_cond = "bucket_id = $bucket_name";
+  std::string scope_cond = "(" + bucket_cond + " AND scope_id = $scope_name)";
+  std::string collection_cond = "(" + scope_cond + " AND keyspace_id = $collection_name)";
 
-    std::string where;
-    if (!collection_name.empty()) {
-        where = collection_cond;
-    } else if (!scope_name.empty()) {
-        where = scope_cond;
-    } else {
-        where = bucket_cond;
-    }
+  std::string where;
+  if (!collection_name.empty()) {
+    where = collection_cond;
+  } else if (!scope_name.empty()) {
+    where = scope_cond;
+  } else {
+    where = bucket_cond;
+  }
 
-    if (collection_name == "_default" || collection_name.empty()) {
-        std::string default_collection_cond = "(bucket_id IS MISSING AND keyspace_id = $bucket_name)";
-        where = "(" + where + " OR " + default_collection_cond + ")";
-    }
+  if (collection_name == "_default" || collection_name.empty()) {
+    std::string default_collection_cond = "(bucket_id IS MISSING AND keyspace_id = $bucket_name)";
+    where = "(" + where + " OR " + default_collection_cond + ")";
+  }
 
-    std::string statement = "SELECT RAW name FROM system:indexes"
-                            " WHERE " +
-                            where +
-                            " AND state = \"deferred\" AND `using` = \"gsi\""
-                            " ORDER BY is_primary DESC, name ASC";
+  std::string statement = "SELECT RAW name FROM system:indexes"
+                          " WHERE " +
+                          where +
+                          " AND state = \"deferred\" AND `using` = \"gsi\""
+                          " ORDER BY is_primary DESC, name ASC";
 
-    encoded.headers["content-type"] = "application/json";
-    tao::json::value body{ { "statement", statement },
-                           { "client_context_id", encoded.client_context_id },
-                           { "$bucket_name", query_ctx.has_value() ? query_ctx.bucket_name() : bucket_name },
-                           { "$scope_name", query_ctx.has_value() ? query_ctx.scope_name() : scope_name },
-                           { "$collection_name", collection_name } };
-    if (query_ctx.has_value()) {
-        body["query_context"] = query_ctx.value();
-    }
-    encoded.method = "POST";
-    encoded.path = "/query/service";
-    encoded.body = utils::json::generate(body);
-    return {};
+  encoded.headers["content-type"] = "application/json";
+  tao::json::value body{
+    { "statement", statement },
+    { "client_context_id", encoded.client_context_id },
+    { "$bucket_name", query_ctx.has_value() ? query_ctx.bucket_name() : bucket_name },
+    { "$scope_name", query_ctx.has_value() ? query_ctx.scope_name() : scope_name },
+    { "$collection_name", collection_name }
+  };
+  if (query_ctx.has_value()) {
+    body["query_context"] = query_ctx.value();
+  }
+  encoded.method = "POST";
+  encoded.path = "/query/service";
+  encoded.body = utils::json::generate(body);
+  return {};
 }
 
 query_index_get_all_deferred_response
-query_index_get_all_deferred_request::make_response(couchbase::core::error_context::http&& ctx, const encoded_response_type& encoded) const
+query_index_get_all_deferred_request::make_response(couchbase::core::error_context::http&& ctx,
+                                                    const encoded_response_type& encoded) const
 {
-    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());
-            return response;
-        }
-        tao::json::value payload{};
-        try {
-            payload = utils::json::parse(encoded.body.data());
-        } catch (const tao::pegtl::parse_error&) {
-            response.ctx.ec = errc::common::parsing_failure;
-            return response;
-        }
-        response.status = payload.at("status").get_string();
-        if (response.status != "success") {
-            return response;
-        }
-        if (encoded.body.data().find("insufficient user permissions") != std::string::npos) {
-            response.ctx.ec = couchbase::errc::common::authentication_failure;
-            return response;
-        }
+  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());
+      return response;
+    }
+    tao::json::value payload{};
+    try {
+      payload = utils::json::parse(encoded.body.data());
+    } catch (const tao::pegtl::parse_error&) {
+      response.ctx.ec = errc::common::parsing_failure;
+      return response;
+    }
+    response.status = payload.at("status").get_string();
+    if (response.status != "success") {
+      return response;
+    }
+    if (encoded.body.data().find("insufficient user permissions") != std::string::npos) {
+      response.ctx.ec = couchbase::errc::common::authentication_failure;
+      return response;
+    }
 
-        for (const auto& entry : payload.at("results").get_array()) {
-            response.index_names.emplace_back(entry.get_string());
-        }
+    for (const auto& entry : payload.at("results").get_array()) {
+      response.index_names.emplace_back(entry.get_string());
     }
-    return response;
+  }
+  return response;
 }
 } // namespace couchbase::core::operations::management

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

@@ -28,30 +28,32 @@
 namespace couchbase::core::operations::management
 {
 struct query_index_get_all_deferred_response {
-    error_context::http ctx;
-    std::string status{};
-    std::vector<std::string> index_names{};
+  error_context::http ctx;
+  std::string status{};
+  std::vector<std::string> index_names{};
 };
 
 struct query_index_get_all_deferred_request {
-    using response_type = query_index_get_all_deferred_response;
-    using encoded_request_type = io::http_request;
-    using encoded_response_type = io::http_response;
-    using error_context_type = error_context::http;
-
-    static const inline service_type type = service_type::query;
-    static constexpr auto namespace_id = "default";
-
-    std::string bucket_name;
-    std::string scope_name;
-    std::string collection_name;
-    query_context query_ctx;
-    std::optional<std::string> client_context_id{};
-    std::optional<std::chrono::milliseconds> timeout{};
-
-    [[nodiscard]] std::error_code encode_to(encoded_request_type& encoded, http_context& context) const;
-
-    [[nodiscard]] query_index_get_all_deferred_response make_response(error_context::http&& ctx,
-                                                                      const encoded_response_type& encoded) const;
+  using response_type = query_index_get_all_deferred_response;
+  using encoded_request_type = io::http_request;
+  using encoded_response_type = io::http_response;
+  using error_context_type = error_context::http;
+
+  static const inline service_type type = service_type::query;
+  static constexpr auto namespace_id = "default";
+
+  std::string bucket_name;
+  std::string scope_name;
+  std::string collection_name;
+  query_context query_ctx;
+  std::optional<std::string> client_context_id{};
+  std::optional<std::chrono::milliseconds> timeout{};
+
+  [[nodiscard]] std::error_code encode_to(encoded_request_type& encoded,
+                                          http_context& context) const;
+
+  [[nodiscard]] query_index_get_all_deferred_response make_response(
+    error_context::http&& ctx,
+    const encoded_response_type& encoded) const;
 };
 } // namespace couchbase::core::operations::management

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

@@ -26,32 +26,34 @@ namespace couchbase::core::operations::management
 std::error_code
 role_get_all_request::encode_to(encoded_request_type& encoded, http_context& /* context */) const
 {
-    encoded.method = "GET";
-    encoded.path = "/settings/rbac/roles";
-    encoded.headers["content-type"] = "application/x-www-form-urlencoded";
-    return {};
+  encoded.method = "GET";
+  encoded.path = "/settings/rbac/roles";
+  encoded.headers["content-type"] = "application/x-www-form-urlencoded";
+  return {};
 }
 
 role_get_all_response
-role_get_all_request::make_response(error_context::http&& ctx, const encoded_response_type& encoded) const
+role_get_all_request::make_response(error_context::http&& ctx,
+                                    const encoded_response_type& encoded) const
 {
-    role_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());
-            return response;
-        }
-        tao::json::value payload{};
-        try {
-            payload = utils::json::parse(encoded.body.data());
-        } catch (const tao::pegtl::parse_error&) {
-            response.ctx.ec = errc::common::parsing_failure;
-            return response;
-        }
-        for (const auto& entry : payload.get_array()) {
-            response.roles.emplace_back(entry.as<couchbase::core::management::rbac::role_and_description>());
-        }
+  role_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());
+      return response;
     }
-    return response;
+    tao::json::value payload{};
+    try {
+      payload = utils::json::parse(encoded.body.data());
+    } catch (const tao::pegtl::parse_error&) {
+      response.ctx.ec = errc::common::parsing_failure;
+      return response;
+    }
+    for (const auto& entry : payload.get_array()) {
+      response.roles.emplace_back(
+        entry.as<couchbase::core::management::rbac::role_and_description>());
+    }
+  }
+  return response;
 }
 } // namespace couchbase::core::operations::management

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

@@ -27,23 +27,25 @@
 namespace couchbase::core::operations::management
 {
 struct role_get_all_response {
-    error_context::http ctx;
-    std::vector<couchbase::core::management::rbac::role_and_description> roles{};
+  error_context::http ctx;
+  std::vector<couchbase::core::management::rbac::role_and_description> roles{};
 };
 
 struct role_get_all_request {
-    using response_type = role_get_all_response;
-    using encoded_request_type = io::http_request;
-    using encoded_response_type = io::http_response;
-    using error_context_type = error_context::http;
+  using response_type = role_get_all_response;
+  using encoded_request_type = io::http_request;
+  using encoded_response_type = io::http_response;
+  using error_context_type = error_context::http;
 
-    static const inline service_type type = service_type::management;
+  static const inline service_type type = service_type::management;
 
-    std::optional<std::string> client_context_id{};
-    std::optional<std::chrono::milliseconds> timeout{};
+  std::optional<std::string> client_context_id{};
+  std::optional<std::chrono::milliseconds> timeout{};
 
-    [[nodiscard]] std::error_code encode_to(encoded_request_type& encoded, http_context& context) const;
+  [[nodiscard]] std::error_code encode_to(encoded_request_type& encoded,
+                                          http_context& context) const;
 
-    [[nodiscard]] role_get_all_response make_response(error_context::http&& ctx, const encoded_response_type& encoded) const;
+  [[nodiscard]] role_get_all_response make_response(error_context::http&& ctx,
+                                                    const encoded_response_type& encoded) const;
 };
 } // namespace couchbase::core::operations::management

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

@@ -30,47 +30,49 @@ namespace couchbase::core::operations::management
 std::error_code
 scope_create_request::encode_to(encoded_request_type& encoded, http_context& /* context */) const
 {
-    encoded.method = "POST";
-    encoded.path = fmt::format("/pools/default/buckets/{}/scopes", bucket_name);
-    encoded.headers["content-type"] = "application/x-www-form-urlencoded";
-    encoded.body = fmt::format("name={}", utils::string_codec::form_encode(scope_name));
-    return {};
+  encoded.method = "POST";
+  encoded.path = fmt::format("/pools/default/buckets/{}/scopes", bucket_name);
+  encoded.headers["content-type"] = "application/x-www-form-urlencoded";
+  encoded.body = fmt::format("name={}", utils::string_codec::form_encode(scope_name));
+  return {};
 }
 
 scope_create_response
-scope_create_request::make_response(error_context::http&& ctx, const encoded_response_type& encoded) const
+scope_create_request::make_response(error_context::http&& ctx,
+                                    const encoded_response_type& encoded) const
 {
-    scope_create_response response{ std::move(ctx) };
-    if (!response.ctx.ec) {
-        switch (encoded.status_code) {
-            case 400: {
-                std::regex scope_exists("Scope with name .+ already exists");
-                if (std::regex_search(encoded.body.data(), scope_exists)) {
-                    response.ctx.ec = errc::management::scope_exists;
-                } else 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;
-            case 404:
-                response.ctx.ec = errc::common::bucket_not_found;
-                break;
-            case 200: {
-                tao::json::value payload{};
-                try {
-                    payload = utils::json::parse(encoded.body.data());
-                } catch (const tao::pegtl::parse_error&) {
-                    response.ctx.ec = errc::common::parsing_failure;
-                    return response;
-                }
-                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());
-                break;
+  scope_create_response response{ std::move(ctx) };
+  if (!response.ctx.ec) {
+    switch (encoded.status_code) {
+      case 400: {
+        std::regex scope_exists("Scope with name .+ already exists");
+        if (std::regex_search(encoded.body.data(), scope_exists)) {
+          response.ctx.ec = errc::management::scope_exists;
+        } else 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;
+      case 404:
+        response.ctx.ec = errc::common::bucket_not_found;
+        break;
+      case 200: {
+        tao::json::value payload{};
+        try {
+          payload = utils::json::parse(encoded.body.data());
+        } catch (const tao::pegtl::parse_error&) {
+          response.ctx.ec = errc::common::parsing_failure;
+          return response;
+        }
+        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());
+        break;
     }
-    return response;
+  }
+  return response;
 }
 } // namespace couchbase::core::operations::management

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

@@ -26,26 +26,28 @@
 namespace couchbase::core::operations::management
 {
 struct scope_create_response {
-    error_context::http ctx;
-    std::uint64_t uid{ 0 };
+  error_context::http ctx;
+  std::uint64_t uid{ 0 };
 };
 
 struct scope_create_request {
-    using response_type = scope_create_response;
-    using encoded_request_type = io::http_request;
-    using encoded_response_type = io::http_response;
-    using error_context_type = error_context::http;
+  using response_type = scope_create_response;
+  using encoded_request_type = io::http_request;
+  using encoded_response_type = io::http_response;
+  using error_context_type = error_context::http;
 
-    static const inline service_type type = service_type::management;
+  static const inline service_type type = service_type::management;
 
-    std::string bucket_name;
-    std::string scope_name;
+  std::string bucket_name;
+  std::string scope_name;
 
-    std::optional<std::string> client_context_id{};
-    std::optional<std::chrono::milliseconds> timeout{};
+  std::optional<std::string> client_context_id{};
+  std::optional<std::chrono::milliseconds> timeout{};
 
-    [[nodiscard]] std::error_code encode_to(encoded_request_type& encoded, http_context& context) const;
+  [[nodiscard]] std::error_code encode_to(encoded_request_type& encoded,
+                                          http_context& context) const;
 
-    [[nodiscard]] scope_create_response make_response(error_context::http&& ctx, const encoded_response_type& encoded) const;
+  [[nodiscard]] scope_create_response make_response(error_context::http&& ctx,
+                                                    const encoded_response_type& encoded) const;
 };
 } // namespace couchbase::core::operations::management

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

@@ -29,43 +29,44 @@ namespace couchbase::core::operations::management
 std::error_code
 scope_drop_request::encode_to(encoded_request_type& encoded, http_context& /* context */) const
 {
-    encoded.method = "DELETE";
-    encoded.path = fmt::format("/pools/default/buckets/{}/scopes/{}", bucket_name, scope_name);
-    return {};
+  encoded.method = "DELETE";
+  encoded.path = fmt::format("/pools/default/buckets/{}/scopes/{}", bucket_name, scope_name);
+  return {};
 }
 
 scope_drop_response
-scope_drop_request::make_response(error_context::http&& ctx, const encoded_response_type& encoded) const
+scope_drop_request::make_response(error_context::http&& ctx,
+                                  const encoded_response_type& encoded) const
 {
-    scope_drop_response response{ std::move(ctx) };
-    if (!response.ctx.ec) {
-        switch (encoded.status_code) {
-            case 400:
-                response.ctx.ec = errc::common::unsupported_operation;
-                break;
-            case 404: {
-                std::regex scope_not_found("Scope with name .+ is not found");
-                if (std::regex_search(encoded.body.data(), scope_not_found)) {
-                    response.ctx.ec = errc::common::scope_not_found;
-                } else {
-                    response.ctx.ec = errc::common::bucket_not_found;
-                }
-            } break;
-            case 200: {
-                tao::json::value payload{};
-                try {
-                    payload = utils::json::parse(encoded.body.data());
-                } catch (const tao::pegtl::parse_error&) {
-                    response.ctx.ec = errc::common::parsing_failure;
-                    return response;
-                }
-                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());
-                break;
+  scope_drop_response response{ std::move(ctx) };
+  if (!response.ctx.ec) {
+    switch (encoded.status_code) {
+      case 400:
+        response.ctx.ec = errc::common::unsupported_operation;
+        break;
+      case 404: {
+        std::regex scope_not_found("Scope with name .+ is not found");
+        if (std::regex_search(encoded.body.data(), scope_not_found)) {
+          response.ctx.ec = errc::common::scope_not_found;
+        } else {
+          response.ctx.ec = errc::common::bucket_not_found;
         }
+      } break;
+      case 200: {
+        tao::json::value payload{};
+        try {
+          payload = utils::json::parse(encoded.body.data());
+        } catch (const tao::pegtl::parse_error&) {
+          response.ctx.ec = errc::common::parsing_failure;
+          return response;
+        }
+        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());
+        break;
     }
-    return response;
+  }
+  return response;
 }
 } // namespace couchbase::core::operations::management

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

@@ -26,26 +26,28 @@
 namespace couchbase::core::operations::management
 {
 struct scope_drop_response {
-    error_context::http ctx;
-    std::uint64_t uid{ 0 };
+  error_context::http ctx;
+  std::uint64_t uid{ 0 };
 };
 
 struct scope_drop_request {
-    using response_type = scope_drop_response;
-    using encoded_request_type = io::http_request;
-    using encoded_response_type = io::http_response;
-    using error_context_type = error_context::http;
+  using response_type = scope_drop_response;
+  using encoded_request_type = io::http_request;
+  using encoded_response_type = io::http_response;
+  using error_context_type = error_context::http;
 
-    static const inline service_type type = service_type::management;
+  static const inline service_type type = service_type::management;
 
-    std::string bucket_name;
-    std::string scope_name;
+  std::string bucket_name;
+  std::string scope_name;
 
-    std::optional<std::string> client_context_id{};
-    std::optional<std::chrono::milliseconds> timeout{};
+  std::optional<std::string> client_context_id{};
+  std::optional<std::chrono::milliseconds> timeout{};
 
-    [[nodiscard]] std::error_code encode_to(encoded_request_type& encoded, http_context& context) const;
+  [[nodiscard]] std::error_code encode_to(encoded_request_type& encoded,
+                                          http_context& context) const;
 
-    [[nodiscard]] scope_drop_response make_response(error_context::http&& ctx, const encoded_response_type& encoded) const;
+  [[nodiscard]] scope_drop_response make_response(error_context::http&& ctx,
+                                                  const encoded_response_type& encoded) const;
 };
 } // namespace couchbase::core::operations::management

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

@@ -28,36 +28,38 @@ namespace couchbase::core::operations::management
 std::error_code
 scope_get_all_request::encode_to(encoded_request_type& encoded, http_context& /* context */) const
 {
-    encoded.method = "GET";
-    encoded.path = fmt::format("/pools/default/buckets/{}/scopes", bucket_name);
-    return {};
+  encoded.method = "GET";
+  encoded.path = fmt::format("/pools/default/buckets/{}/scopes", bucket_name);
+  return {};
 }
 
 scope_get_all_response
-scope_get_all_request::make_response(error_context::http&& ctx, const encoded_response_type& encoded) const
+scope_get_all_request::make_response(error_context::http&& ctx,
+                                     const encoded_response_type& encoded) const
 {
-    scope_get_all_response response{ std::move(ctx) };
-    if (!response.ctx.ec) {
-        switch (encoded.status_code) {
-            case 400:
-                response.ctx.ec = errc::common::unsupported_operation;
-                break;
-            case 404:
-                response.ctx.ec = errc::common::bucket_not_found;
-                break;
-            case 200:
-                try {
-                    response.manifest = utils::json::parse(encoded.body.data()).as<topology::collections_manifest>();
-                } catch (const tao::pegtl::parse_error&) {
-                    response.ctx.ec = errc::common::parsing_failure;
-                    return response;
-                }
-                break;
-            default:
-                response.ctx.ec = extract_common_error_code(encoded.status_code, encoded.body.data());
-                break;
+  scope_get_all_response response{ std::move(ctx) };
+  if (!response.ctx.ec) {
+    switch (encoded.status_code) {
+      case 400:
+        response.ctx.ec = errc::common::unsupported_operation;
+        break;
+      case 404:
+        response.ctx.ec = errc::common::bucket_not_found;
+        break;
+      case 200:
+        try {
+          response.manifest =
+            utils::json::parse(encoded.body.data()).as<topology::collections_manifest>();
+        } catch (const tao::pegtl::parse_error&) {
+          response.ctx.ec = errc::common::parsing_failure;
+          return response;
         }
+        break;
+      default:
+        response.ctx.ec = extract_common_error_code(encoded.status_code, encoded.body.data());
+        break;
     }
-    return response;
+  }
+  return response;
 }
 } // namespace couchbase::core::operations::management