couchbase 4.3.1 → 4.4.1-dev.1

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

@@ -28,28 +28,31 @@
 namespace couchbase::core::operations::management
 {
 struct eventing_upsert_function_response {
-    error_context::http ctx;
-    std::optional<eventing_problem> error{};
+  error_context::http ctx;
+  std::optional<eventing_problem> error{};
 };
 
 struct eventing_upsert_function_request {
-    using response_type = eventing_upsert_function_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 = eventing_upsert_function_response;
+  using encoded_request_type = io::http_request;
+  using encoded_response_type = io::http_response;
+  using error_context_type = error_context::http;
 
-    couchbase::core::management::eventing::function function{};
+  couchbase::core::management::eventing::function function{};
 
-    std::optional<std::string> bucket_name{};
-    std::optional<std::string> scope_name{};
+  std::optional<std::string> bucket_name{};
+  std::optional<std::string> scope_name{};
 
-    static const inline service_type type = service_type::eventing;
+  static const inline service_type type = service_type::eventing;
 
-    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]] eventing_upsert_function_response make_response(error_context::http&& ctx, const encoded_response_type& encoded) const;
+  [[nodiscard]] eventing_upsert_function_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/freeform.cxx

@@ -24,31 +24,32 @@ namespace couchbase::core::operations::management
 std::error_code
 freeform_request::encode_to(encoded_request_type& encoded, http_context& /* context */) const
 {
-    switch (type) {
-        case service_type::query:
-        case service_type::analytics:
-        case service_type::search:
-        case service_type::view:
-        case service_type::management:
-        case service_type::eventing:
-            break;
-        default:
-            return errc::common::invalid_argument;
-    }
-    encoded.method = method;
-    encoded.headers = headers;
-    encoded.path = path;
-    encoded.body = body;
-    return {};
+  switch (type) {
+    case service_type::query:
+    case service_type::analytics:
+    case service_type::search:
+    case service_type::view:
+    case service_type::management:
+    case service_type::eventing:
+      break;
+    default:
+      return errc::common::invalid_argument;
+  }
+  encoded.method = method;
+  encoded.headers = headers;
+  encoded.path = path;
+  encoded.body = body;
+  return {};
 }
 
 freeform_response
-freeform_request::make_response(error_context::http&& ctx, const encoded_response_type& encoded) const
+freeform_request::make_response(error_context::http&& ctx,
+                                const encoded_response_type& encoded) const
 {
-    freeform_response response{ std::move(ctx) };
-    response.status = encoded.status_code;
-    response.headers = encoded.headers;
-    response.body = encoded.body.data();
-    return response;
+  freeform_response response{ std::move(ctx) };
+  response.status = encoded.status_code;
+  response.headers = encoded.headers;
+  response.body = encoded.body.data();
+  return response;
 }
 } // namespace couchbase::core::operations::management

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

@@ -27,29 +27,31 @@
 namespace couchbase::core::operations::management
 {
 struct freeform_response {
-    error_context::http ctx;
-    std::uint32_t status{};
-    std::map<std::string, std::string> headers{};
-    std::string body{};
+  error_context::http ctx;
+  std::uint32_t status{};
+  std::map<std::string, std::string> headers{};
+  std::string body{};
 };
 
 struct freeform_request {
-    using response_type = freeform_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 = freeform_response;
+  using encoded_request_type = io::http_request;
+  using encoded_response_type = io::http_response;
+  using error_context_type = error_context::http;
 
-    service_type type;
-    std::string method;
-    std::string path;
-    std::map<std::string, std::string> headers{};
-    std::string body{};
+  service_type type;
+  std::string method;
+  std::string path;
+  std::map<std::string, std::string> headers{};
+  std::string body{};
 
-    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]] freeform_response make_response(error_context::http&& ctx, const encoded_response_type& encoded) const;
+  [[nodiscard]] freeform_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/group_drop.cxx

@@ -26,27 +26,28 @@ namespace couchbase::core::operations::management
 std::error_code
 group_drop_request::encode_to(encoded_request_type& encoded, http_context& /* context */) const
 {
-    encoded.method = "DELETE";
-    encoded.path = fmt::format("/settings/rbac/groups/{}", name);
-    return {};
+  encoded.method = "DELETE";
+  encoded.path = fmt::format("/settings/rbac/groups/{}", name);
+  return {};
 }
 
 group_drop_response
-group_drop_request::make_response(error_context::http&& ctx, const encoded_response_type& encoded) const
+group_drop_request::make_response(error_context::http&& ctx,
+                                  const encoded_response_type& encoded) const
 {
-    group_drop_response response{ std::move(ctx) };
-    if (!response.ctx.ec) {
-        switch (encoded.status_code) {
-            case 200:
-                break;
-            case 404:
-                response.ctx.ec = errc::management::group_not_found;
-                break;
-            default:
-                response.ctx.ec = extract_common_error_code(encoded.status_code, encoded.body.data());
-                break;
-        }
+  group_drop_response response{ std::move(ctx) };
+  if (!response.ctx.ec) {
+    switch (encoded.status_code) {
+      case 200:
+        break;
+      case 404:
+        response.ctx.ec = errc::management::group_not_found;
+        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/group_drop.hxx

@@ -26,24 +26,26 @@
 namespace couchbase::core::operations::management
 {
 struct group_drop_response {
-    error_context::http ctx;
+  error_context::http ctx;
 };
 
 struct group_drop_request {
-    using response_type = group_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 = group_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 name{};
+  std::string 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]] group_drop_response make_response(error_context::http&& ctx, const encoded_response_type& encoded) const;
+  [[nodiscard]] group_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/group_get.cxx

@@ -28,34 +28,36 @@ namespace couchbase::core::operations::management
 std::error_code
 group_get_request::encode_to(encoded_request_type& encoded, http_context& /* context */) const
 {
-    encoded.method = "GET";
-    encoded.path = fmt::format("/settings/rbac/groups/{}", name);
-    encoded.headers["content-type"] = "application/x-www-form-urlencoded";
-    return {};
+  encoded.method = "GET";
+  encoded.path = fmt::format("/settings/rbac/groups/{}", name);
+  encoded.headers["content-type"] = "application/x-www-form-urlencoded";
+  return {};
 }
 
 group_get_response
-group_get_request::make_response(error_context::http&& ctx, const encoded_response_type& encoded) const
+group_get_request::make_response(error_context::http&& ctx,
+                                 const encoded_response_type& encoded) const
 {
-    group_get_response response{ std::move(ctx) };
-    if (!response.ctx.ec) {
-        switch (encoded.status_code) {
-            case 200: {
-                try {
-                    response.group = utils::json::parse(encoded.body.data()).as<couchbase::core::management::rbac::group>();
-                } catch (const tao::pegtl::parse_error&) {
-                    response.ctx.ec = errc::common::parsing_failure;
-                    return response;
-                }
-            } break;
-            case 404:
-                response.ctx.ec = errc::management::group_not_found;
-                break;
-            default:
-                response.ctx.ec = extract_common_error_code(encoded.status_code, encoded.body.data());
-                break;
+  group_get_response response{ std::move(ctx) };
+  if (!response.ctx.ec) {
+    switch (encoded.status_code) {
+      case 200: {
+        try {
+          response.group =
+            utils::json::parse(encoded.body.data()).as<couchbase::core::management::rbac::group>();
+        } catch (const tao::pegtl::parse_error&) {
+          response.ctx.ec = errc::common::parsing_failure;
+          return response;
         }
+      } break;
+      case 404:
+        response.ctx.ec = errc::management::group_not_found;
+        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/group_get.hxx

@@ -27,24 +27,26 @@
 namespace couchbase::core::operations::management
 {
 struct group_get_response {
-    error_context::http ctx;
-    couchbase::core::management::rbac::group group{};
+  error_context::http ctx;
+  couchbase::core::management::rbac::group group{};
 };
 
 struct group_get_request {
-    using response_type = group_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 = group_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::management;
+  static const inline service_type type = service_type::management;
 
-    std::string name{};
+  std::string 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]] group_get_response make_response(error_context::http&& ctx, const encoded_response_type& encoded) const;
+  [[nodiscard]] std::error_code encode_to(encoded_request_type& encoded,
+                                          http_context& context) const;
+  [[nodiscard]] group_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/group_get_all.cxx

@@ -26,32 +26,33 @@ namespace couchbase::core::operations::management
 std::error_code
 group_get_all_request::encode_to(encoded_request_type& encoded, http_context& /* context */) const
 {
-    encoded.method = "GET";
-    encoded.path = "/settings/rbac/groups";
-    encoded.headers["content-type"] = "application/x-www-form-urlencoded";
-    return {};
+  encoded.method = "GET";
+  encoded.path = "/settings/rbac/groups";
+  encoded.headers["content-type"] = "application/x-www-form-urlencoded";
+  return {};
 }
 
 group_get_all_response
-group_get_all_request::make_response(error_context::http&& ctx, const encoded_response_type& encoded) const
+group_get_all_request::make_response(error_context::http&& ctx,
+                                     const encoded_response_type& encoded) const
 {
-    group_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.groups.emplace_back(entry.as<couchbase::core::management::rbac::group>());
-        }
+  group_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.groups.emplace_back(entry.as<couchbase::core::management::rbac::group>());
+    }
+  }
+  return response;
 }
 } // namespace couchbase::core::operations::management

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

@@ -27,23 +27,25 @@
 namespace couchbase::core::operations::management
 {
 struct group_get_all_response {
-    error_context::http ctx;
-    std::vector<couchbase::core::management::rbac::group> groups{};
+  error_context::http ctx;
+  std::vector<couchbase::core::management::rbac::group> groups{};
 };
 
 struct group_get_all_request {
-    using response_type = group_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 = group_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]] group_get_all_response make_response(error_context::http&& ctx, const encoded_response_type& encoded) const;
+  [[nodiscard]] group_get_all_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/group_upsert.cxx

@@ -27,69 +27,72 @@ namespace couchbase::core::operations::management
 std::error_code
 group_upsert_request::encode_to(encoded_request_type& encoded, http_context& /* context */) const
 {
-    encoded.method = "PUT";
-    encoded.path = fmt::format("/settings/rbac/groups/{}", group.name);
-    std::vector<std::string> params{};
-    if (group.description) {
-        params.push_back(fmt::format("description={}", utils::string_codec::url_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())));
-    }
-    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("[{}", 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/groups/{}", group.name);
+  std::vector<std::string> params{};
+  if (group.description) {
+    params.push_back(
+      fmt::format("description={}", utils::string_codec::url_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())));
+  }
+  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("[{}", 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 = fmt::format("{}", 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 = fmt::format("{}", 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 {};
 }
 
 group_upsert_response
-group_upsert_request::make_response(error_context::http&& ctx, const encoded_response_type& encoded) const
+group_upsert_request::make_response(error_context::http&& ctx,
+                                    const encoded_response_type& encoded) const
 {
-    group_upsert_response response{ std::move(ctx) };
-    if (!response.ctx.ec) {
-        switch (encoded.status_code) {
-            case 200:
-                break;
-            case 400: {
-                response.ctx.ec = errc::common::invalid_argument;
-                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;
-                }
+  group_upsert_response response{ std::move(ctx) };
+  if (!response.ctx.ec) {
+    switch (encoded.status_code) {
+      case 200:
+        break;
+      case 400: {
+        response.ctx.ec = errc::common::invalid_argument;
+        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;
+        }
 
-                if (const auto* errors = payload.find("errors"); 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;
+        if (const auto* errors = payload.find("errors"); 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/group_upsert.hxx

@@ -27,25 +27,27 @@
 namespace couchbase::core::operations::management
 {
 struct group_upsert_response {
-    error_context::http ctx;
-    std::vector<std::string> errors{};
+  error_context::http ctx;
+  std::vector<std::string> errors{};
 };
 
 struct group_upsert_request {
-    using response_type = group_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 = group_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::group group{};
+  couchbase::core::management::rbac::group group{};
 
-    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]] group_upsert_response make_response(error_context::http&& ctx, const encoded_response_type& encoded) const;
+  [[nodiscard]] group_upsert_response make_response(error_context::http&& ctx,
+                                                    const encoded_response_type& encoded) const;
 };
 } // namespace couchbase::core::operations::management