couchbase 4.3.1 → 4.4.1-dev.1

package/deps/couchbase-cxx-client/core/operations/management/user_upsert.cxx

@@ -28,73 +28,76 @@ namespace couchbase::core::operations::management
 std::error_code
 user_upsert_request::encode_to(encoded_request_type& encoded, http_context& /* context */) const
 {
-    encoded.method = "PUT";
-    encoded.path = fmt::format("/settings/rbac/users/{}/{}", domain, 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())));
-    }
-    if (user.password) {
-        params.push_back(fmt::format("password={}", utils::string_codec::url_encode(user.password.value())));
-    }
-    if (!user.groups.empty()) {
-        std::string encoded_groups = utils::join_strings(user.groups, ",");
-        params.push_back(fmt::format("groups={}", utils::string_codec::url_encode(encoded_groups)));
-    }
-    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("[{}", role.bucket.value());
-            if (role.scope) {
-                spec += fmt::format(":{}", role.scope.value());
-                if (role.collection) {
-                    spec += fmt::format(":{}", role.collection.value());
-                }
-            }
-            spec += "]";
+  encoded.method = "PUT";
+  encoded.path = fmt::format("/settings/rbac/users/{}/{}", domain, 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())));
+  }
+  if (user.password) {
+    params.push_back(
+      fmt::format("password={}", utils::string_codec::url_encode(user.password.value())));
+  }
+  if (!user.groups.empty()) {
+    std::string encoded_groups = utils::join_strings(user.groups, ",");
+    params.push_back(fmt::format("groups={}", utils::string_codec::url_encode(encoded_groups)));
+  }
+  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("[{}", role.bucket.value());
+      if (role.scope) {
+        spec += fmt::format(":{}", role.scope.value());
+        if (role.collection) {
+          spec += fmt::format(":{}", role.collection.value());
         }
-        encoded_roles.push_back(spec);
+      }
+      spec += "]";
     }
-    if (!encoded_roles.empty()) {
-        std::string concatenated = utils::join_strings(encoded_roles, ",");
-        params.push_back(fmt::format("roles={}", utils::string_codec::url_encode(concatenated)));
-    }
-    encoded.body = utils::join_strings(params, "&");
-    encoded.headers["content-type"] = "application/x-www-form-urlencoded";
-    return {};
+    encoded_roles.push_back(spec);
+  }
+  if (!encoded_roles.empty()) {
+    std::string concatenated = utils::join_strings(encoded_roles, ",");
+    params.push_back(fmt::format("roles={}", utils::string_codec::url_encode(concatenated)));
+  }
+  encoded.body = utils::join_strings(params, "&");
+  encoded.headers["content-type"] = "application/x-www-form-urlencoded";
+  return {};
 }
 
 user_upsert_response
-user_upsert_request::make_response(error_context::http&& ctx, const encoded_response_type& encoded) const
+user_upsert_request::make_response(error_context::http&& ctx,
+                                   const encoded_response_type& encoded) const
 {
-    user_upsert_response response{ std::move(ctx) };
-    if (!response.ctx.ec) {
-        switch (encoded.status_code) {
-            case 200:
-                break;
-            case 400: {
-                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.ctx.ec = errc::common::invalid_argument;
-                const auto* errors = payload.find("errors");
-                if (errors != nullptr && errors->is_object()) {
-                    for (const auto& [code, message] : errors->get_object()) {
-                        response.errors.emplace_back(fmt::format("{}: {}", code, message.get_string()));
-                    }
-                }
-            } break;
-            default:
-                response.ctx.ec = extract_common_error_code(encoded.status_code, encoded.body.data());
-                break;
+  user_upsert_response response{ std::move(ctx) };
+  if (!response.ctx.ec) {
+    switch (encoded.status_code) {
+      case 200:
+        break;
+      case 400: {
+        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.ctx.ec = errc::common::invalid_argument;
+        const auto* errors = payload.find("errors");
+        if (errors != nullptr && errors->is_object()) {
+          for (const auto& [code, message] : errors->get_object()) {
+            response.errors.emplace_back(fmt::format("{}: {}", code, message.get_string()));
+          }
         }
+      } 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

package/deps/couchbase-cxx-client/core/operations/management/user_upsert.hxx

@@ -27,26 +27,30 @@
 namespace couchbase::core::operations::management
 {
 struct user_upsert_response {
-    error_context::http ctx;
-    std::vector<std::string> errors{};
+  error_context::http ctx;
+  std::vector<std::string> errors{};
 };
 
 struct user_upsert_request {
-    using response_type = user_upsert_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 = user_upsert_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;
 
-    couchbase::core::management::rbac::auth_domain domain{ couchbase::core::management::rbac::auth_domain::local };
-    couchbase::core::management::rbac::user user{};
+  couchbase::core::management::rbac::auth_domain domain{
+    couchbase::core::management::rbac::auth_domain::local
+  };
+  couchbase::core::management::rbac::user user{};
 
-    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]] user_upsert_response make_response(error_context::http&& ctx, const encoded_response_type& encoded) const;
+  [[nodiscard]] user_upsert_response make_response(error_context::http&& ctx,
+                                                   const encoded_response_type& encoded) const;
 };
 } // namespace couchbase::core::operations::management

package/deps/couchbase-cxx-client/core/operations/management/view_index_drop.cxx

@@ -26,22 +26,26 @@ namespace couchbase::core::operations::management
 std::error_code
 view_index_drop_request::encode_to(encoded_request_type& encoded, http_context& /* context */) const
 {
-    encoded.method = "DELETE";
-    encoded.path = fmt::format("/{}/_design/{}{}", bucket_name, ns == design_document_namespace::development ? "dev_" : "", document_name);
-    return {};
+  encoded.method = "DELETE";
+  encoded.path = fmt::format("/{}/_design/{}{}",
+                             bucket_name,
+                             ns == design_document_namespace::development ? "dev_" : "",
+                             document_name);
+  return {};
 }
 
 view_index_drop_response
-view_index_drop_request::make_response(error_context::http&& ctx, const encoded_response_type& encoded) const
+view_index_drop_request::make_response(error_context::http&& ctx,
+                                       const encoded_response_type& encoded) const
 {
-    view_index_drop_response response{ std::move(ctx) };
-    if (!response.ctx.ec) {
-        if (encoded.status_code == 404) {
-            response.ctx.ec = errc::view::design_document_not_found;
-        } else if (encoded.status_code != 200) {
-            response.ctx.ec = extract_common_error_code(encoded.status_code, encoded.body.data());
-        }
+  view_index_drop_response response{ std::move(ctx) };
+  if (!response.ctx.ec) {
+    if (encoded.status_code == 404) {
+      response.ctx.ec = errc::view::design_document_not_found;
+    } else if (encoded.status_code != 200) {
+      response.ctx.ec = extract_common_error_code(encoded.status_code, encoded.body.data());
     }
-    return response;
+  }
+  return response;
 }
 } // namespace couchbase::core::operations::management

package/deps/couchbase-cxx-client/core/operations/management/view_index_drop.hxx

@@ -27,26 +27,28 @@
 namespace couchbase::core::operations::management
 {
 struct view_index_drop_response {
-    error_context::http ctx;
+  error_context::http ctx;
 };
 
 struct view_index_drop_request {
-    using response_type = view_index_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 = view_index_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::view;
+  static const inline service_type type = service_type::view;
 
-    std::string bucket_name;
-    std::string document_name;
-    design_document_namespace ns;
+  std::string bucket_name;
+  std::string document_name;
+  design_document_namespace ns;
 
-    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]] view_index_drop_response make_response(error_context::http&& ctx, const encoded_response_type& encoded) const;
+  [[nodiscard]] view_index_drop_response make_response(error_context::http&& ctx,
+                                                       const encoded_response_type& encoded) const;
 };
 } // namespace couchbase::core::operations::management

package/deps/couchbase-cxx-client/core/operations/management/view_index_get.cxx

@@ -27,49 +27,54 @@ namespace couchbase::core::operations::management
 std::error_code
 view_index_get_request::encode_to(encoded_request_type& encoded, http_context& /* context */) const
 {
-    encoded.method = "GET";
-    encoded.path = fmt::format("/{}/_design/{}{}", bucket_name, ns == design_document_namespace::development ? "dev_" : "", document_name);
-    return {};
+  encoded.method = "GET";
+  encoded.path = fmt::format("/{}/_design/{}{}",
+                             bucket_name,
+                             ns == design_document_namespace::development ? "dev_" : "",
+                             document_name);
+  return {};
 }
 
 view_index_get_response
-view_index_get_request::make_response(error_context::http&& ctx, const encoded_response_type& encoded) const
+view_index_get_request::make_response(error_context::http&& ctx,
+                                      const encoded_response_type& encoded) const
 {
-    view_index_get_response response{ std::move(ctx) };
-    if (!response.ctx.ec) {
-        if (encoded.status_code == 200) {
-            response.document.name = document_name;
-            response.document.ns = ns;
+  view_index_get_response response{ std::move(ctx) };
+  if (!response.ctx.ec) {
+    if (encoded.status_code == 200) {
+      response.document.name = document_name;
+      response.document.ns = ns;
 
-            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;
+      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;
+      }
+      const auto* views = payload.find("views");
+      if (views != nullptr && views->is_object()) {
+        for (const auto& [name, view_entry] : views->get_object()) {
+          couchbase::core::management::views::design_document::view view;
+          view.name = name;
+          if (view_entry.is_object()) {
+            if (const auto* map = view_entry.find("map"); map != nullptr && map->is_string()) {
+              view.map = map->get_string();
             }
-            const auto* views = payload.find("views");
-            if (views != nullptr && views->is_object()) {
-                for (const auto& [name, view_entry] : views->get_object()) {
-                    couchbase::core::management::views::design_document::view view;
-                    view.name = name;
-                    if (view_entry.is_object()) {
-                        if (const auto* map = view_entry.find("map"); map != nullptr && map->is_string()) {
-                            view.map = map->get_string();
-                        }
-                        if (const auto* reduce = view_entry.find("reduce"); reduce != nullptr && reduce->is_string()) {
-                            view.reduce = reduce->get_string();
-                        }
-                    }
-                    response.document.views[view.name] = view;
-                }
+            if (const auto* reduce = view_entry.find("reduce");
+                reduce != nullptr && reduce->is_string()) {
+              view.reduce = reduce->get_string();
             }
-        } else if (encoded.status_code == 404) {
-            response.ctx.ec = errc::view::design_document_not_found;
-        } else {
-            response.ctx.ec = extract_common_error_code(encoded.status_code, encoded.body.data());
+          }
+          response.document.views[view.name] = view;
         }
+      }
+    } else if (encoded.status_code == 404) {
+      response.ctx.ec = errc::view::design_document_not_found;
+    } else {
+      response.ctx.ec = extract_common_error_code(encoded.status_code, encoded.body.data());
     }
-    return response;
+  }
+  return response;
 }
 } // namespace couchbase::core::operations::management

package/deps/couchbase-cxx-client/core/operations/management/view_index_get.hxx

@@ -27,27 +27,29 @@
 namespace couchbase::core::operations::management
 {
 struct view_index_get_response {
-    error_context::http ctx;
-    couchbase::core::management::views::design_document document{};
+  error_context::http ctx;
+  couchbase::core::management::views::design_document document{};
 };
 
 struct view_index_get_request {
-    using response_type = view_index_get_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 = view_index_get_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::view;
+  static const inline service_type type = service_type::view;
 
-    std::string bucket_name;
-    std::string document_name;
-    design_document_namespace ns;
+  std::string bucket_name;
+  std::string document_name;
+  design_document_namespace ns;
 
-    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]] view_index_get_response make_response(error_context::http&& ctx, const encoded_response_type& encoded) const;
+  [[nodiscard]] view_index_get_response make_response(error_context::http&& ctx,
+                                                      const encoded_response_type& encoded) const;
 };
 } // namespace couchbase::core::operations::management

package/deps/couchbase-cxx-client/core/operations/management/view_index_get_all.cxx

@@ -25,85 +25,89 @@
 namespace couchbase::core::operations::management
 {
 std::error_code
-view_index_get_all_request::encode_to(encoded_request_type& encoded, http_context& /* context */) const
+view_index_get_all_request::encode_to(encoded_request_type& encoded,
+                                      http_context& /* context */) const
 {
-    encoded.method = "GET";
-    encoded.path = fmt::format("/pools/default/buckets/{}/ddocs", bucket_name);
-    return {};
+  encoded.method = "GET";
+  encoded.path = fmt::format("/pools/default/buckets/{}/ddocs", bucket_name);
+  return {};
 }
 
 view_index_get_all_response
-view_index_get_all_request::make_response(error_context::http&& ctx, const encoded_response_type& encoded) const
+view_index_get_all_request::make_response(error_context::http&& ctx,
+                                          const encoded_response_type& encoded) const
 {
-    view_index_get_all_response response{ std::move(ctx) };
-    if (!response.ctx.ec) {
-        if (encoded.status_code == 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;
-            }
-            auto* rows = payload.find("rows");
-            if (rows != nullptr && rows->is_array()) {
-                for (const auto& entry : rows->get_array()) {
-                    const auto* dd = entry.find("doc");
-                    if (dd == nullptr || !dd->is_object()) {
-                        continue;
-                    }
-                    const auto* meta = dd->find("meta");
-                    if (meta == nullptr || !meta->is_object()) {
-                        continue;
-                    }
-
-                    couchbase::core::management::views::design_document document{};
-                    document.rev = meta->at("rev").get_string();
-                    auto id = meta->at("id").get_string();
-                    if (static const std::string prefix = "_design/"; id.find(prefix) == 0) {
-                        document.name = id.substr(prefix.size());
-                    } else {
-                        document.name = id; // fall back, should not happen
-                    }
-                    if (static const std::string namespace_prefix = "dev_"; document.name.find(namespace_prefix) == 0) {
-                        document.name = document.name.substr(namespace_prefix.size());
-                        document.ns = couchbase::core::design_document_namespace::development;
-                    } else {
-                        document.ns = couchbase::core::design_document_namespace::production;
-                    }
-                    if (document.ns != ns) {
-                        continue;
-                    }
+  view_index_get_all_response response{ std::move(ctx) };
+  if (!response.ctx.ec) {
+    if (encoded.status_code == 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;
+      }
+      auto* rows = payload.find("rows");
+      if (rows != nullptr && rows->is_array()) {
+        for (const auto& entry : rows->get_array()) {
+          const auto* dd = entry.find("doc");
+          if (dd == nullptr || !dd->is_object()) {
+            continue;
+          }
+          const auto* meta = dd->find("meta");
+          if (meta == nullptr || !meta->is_object()) {
+            continue;
+          }
 
-                    const auto* json = dd->find("json");
-                    if (json == nullptr || !json->is_object()) {
-                        continue;
-                    }
-                    if (const auto* views = json->find("views"); views != nullptr && views->is_object()) {
-                        for (const auto& [name, view_entry] : views->get_object()) {
-                            couchbase::core::management::views::design_document::view view;
-                            view.name = name;
-                            if (view_entry.is_object()) {
-                                if (const auto* map = view_entry.find("map"); map != nullptr && map->is_string()) {
-                                    view.map = map->get_string();
-                                }
-                                if (const auto* reduce = view_entry.find("reduce"); reduce != nullptr && reduce->is_string()) {
-                                    view.reduce = reduce->get_string();
-                                }
-                            }
-                            document.views[view.name] = view;
-                        }
-                    }
+          couchbase::core::management::views::design_document document{};
+          document.rev = meta->at("rev").get_string();
+          auto id = meta->at("id").get_string();
+          if (static const std::string prefix = "_design/"; id.find(prefix) == 0) {
+            document.name = id.substr(prefix.size());
+          } else {
+            document.name = id; // fall back, should not happen
+          }
+          if (static const std::string namespace_prefix = "dev_";
+              document.name.find(namespace_prefix) == 0) {
+            document.name = document.name.substr(namespace_prefix.size());
+            document.ns = couchbase::core::design_document_namespace::development;
+          } else {
+            document.ns = couchbase::core::design_document_namespace::production;
+          }
+          if (document.ns != ns) {
+            continue;
+          }
 
-                    response.design_documents.emplace_back(document);
+          const auto* json = dd->find("json");
+          if (json == nullptr || !json->is_object()) {
+            continue;
+          }
+          if (const auto* views = json->find("views"); views != nullptr && views->is_object()) {
+            for (const auto& [name, view_entry] : views->get_object()) {
+              couchbase::core::management::views::design_document::view view;
+              view.name = name;
+              if (view_entry.is_object()) {
+                if (const auto* map = view_entry.find("map"); map != nullptr && map->is_string()) {
+                  view.map = map->get_string();
                 }
+                if (const auto* reduce = view_entry.find("reduce");
+                    reduce != nullptr && reduce->is_string()) {
+                  view.reduce = reduce->get_string();
+                }
+              }
+              document.views[view.name] = view;
             }
-        } else if (encoded.status_code == 404) {
-            response.ctx.ec = errc::common::bucket_not_found;
-        } else {
-            response.ctx.ec = extract_common_error_code(encoded.status_code, encoded.body.data());
+          }
+
+          response.design_documents.emplace_back(document);
         }
+      }
+    } else if (encoded.status_code == 404) {
+      response.ctx.ec = errc::common::bucket_not_found;
+    } else {
+      response.ctx.ec = extract_common_error_code(encoded.status_code, encoded.body.data());
     }
-    return response;
+  }
+  return response;
 }
 } // namespace couchbase::core::operations::management

package/deps/couchbase-cxx-client/core/operations/management/view_index_get_all.hxx

@@ -27,26 +27,29 @@
 namespace couchbase::core::operations::management
 {
 struct view_index_get_all_response {
-    error_context::http ctx;
-    std::vector<couchbase::core::management::views::design_document> design_documents{};
+  error_context::http ctx;
+  std::vector<couchbase::core::management::views::design_document> design_documents{};
 };
 
 struct view_index_get_all_request {
-    using response_type = view_index_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 = view_index_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::string bucket_name;
-    design_document_namespace ns;
+  std::string bucket_name;
+  design_document_namespace ns;
 
-    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]] view_index_get_all_response make_response(error_context::http&& ctx, const encoded_response_type& encoded) const;
+  [[nodiscard]] view_index_get_all_response make_response(
+    error_context::http&& ctx,
+    const encoded_response_type& encoded) const;
 };
 } // namespace couchbase::core::operations::management