couchbase 4.3.1 → 4.4.0

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

@@ -28,32 +28,34 @@ namespace couchbase::core::operations
 namespace management
 {
 struct search_index_control_plan_freeze_response {
-    error_context::http ctx;
-    std::string status{};
-    std::string error{};
+  error_context::http ctx;
+  std::string status{};
+  std::string error{};
 };
 
 struct search_index_control_plan_freeze_request {
-    using response_type = search_index_control_plan_freeze_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 = search_index_control_plan_freeze_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::search;
+  static const inline service_type type = service_type::search;
 
-    std::string index_name;
-    bool freeze;
+  std::string index_name;
+  bool freeze;
 
-    std::optional<std::string> bucket_name;
-    std::optional<std::string> scope_name;
+  std::optional<std::string> bucket_name;
+  std::optional<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]] search_index_control_plan_freeze_response make_response(error_context::http&& ctx,
-                                                                          const encoded_response_type& encoded) const;
+  [[nodiscard]] search_index_control_plan_freeze_response make_response(
+    error_context::http&& ctx,
+    const encoded_response_type& encoded) const;
 };
 } // namespace management
 

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

@@ -25,70 +25,73 @@
 namespace couchbase::core::operations::management
 {
 std::error_code
-search_index_control_query_request::encode_to(encoded_request_type& encoded, http_context& /* context */) const
+search_index_control_query_request::encode_to(encoded_request_type& encoded,
+                                              http_context& /* context */) const
 {
-    if (index_name.empty()) {
-        return errc::common::invalid_argument;
-    }
-    encoded.method = "POST";
-    if (bucket_name.has_value() && scope_name.has_value()) {
-        encoded.path = fmt::format("/api/bucket/{}/scope/{}/index/{}/queryControl/{}",
-                                   bucket_name.value(),
-                                   scope_name.value(),
-                                   index_name,
-                                   allow ? "allow" : "disallow");
-    } else {
-        encoded.path = fmt::format("/api/index/{}/queryControl/{}", index_name, allow ? "allow" : "disallow");
-    }
-    return {};
+  if (index_name.empty()) {
+    return errc::common::invalid_argument;
+  }
+  encoded.method = "POST";
+  if (bucket_name.has_value() && scope_name.has_value()) {
+    encoded.path = fmt::format("/api/bucket/{}/scope/{}/index/{}/queryControl/{}",
+                               bucket_name.value(),
+                               scope_name.value(),
+                               index_name,
+                               allow ? "allow" : "disallow");
+  } else {
+    encoded.path =
+      fmt::format("/api/index/{}/queryControl/{}", index_name, allow ? "allow" : "disallow");
+  }
+  return {};
 }
 
 search_index_control_query_response
-search_index_control_query_request::make_response(error_context::http&& ctx, const encoded_response_type& encoded) const
+search_index_control_query_request::make_response(error_context::http&& ctx,
+                                                  const encoded_response_type& encoded) const
 {
-    search_index_control_query_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;
-            }
-            response.status = payload.at("status").get_string();
-            if (response.status == "ok") {
-                return response;
-            }
-        } else if (encoded.status_code == 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.status = payload.at("status").get_string();
-            response.error = payload.at("error").get_string();
-            if (response.error.find("index not found") != std::string::npos) {
-                response.ctx.ec = errc::common::index_not_found;
-                return response;
-            }
-        } else if (encoded.status_code == 404) {
-            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();
-            response.error = payload.at("error").get_string();
-            response.ctx.ec = errc::common::feature_not_available;
-            return response;
-        }
-        response.ctx.ec = extract_common_error_code(encoded.status_code, encoded.body.data());
+  search_index_control_query_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;
+      }
+      response.status = payload.at("status").get_string();
+      if (response.status == "ok") {
+        return response;
+      }
+    } else if (encoded.status_code == 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.status = payload.at("status").get_string();
+      response.error = payload.at("error").get_string();
+      if (response.error.find("index not found") != std::string::npos) {
+        response.ctx.ec = errc::common::index_not_found;
+        return response;
+      }
+    } else if (encoded.status_code == 404) {
+      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();
+      response.error = payload.at("error").get_string();
+      response.ctx.ec = errc::common::feature_not_available;
+      return response;
     }
-    return response;
+    response.ctx.ec = extract_common_error_code(encoded.status_code, encoded.body.data());
+  }
+  return response;
 }
 } // namespace couchbase::core::operations::management

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

@@ -26,30 +26,33 @@
 namespace couchbase::core::operations::management
 {
 struct search_index_control_query_response {
-    error_context::http ctx;
-    std::string status{};
-    std::string error{};
+  error_context::http ctx;
+  std::string status{};
+  std::string error{};
 };
 
 struct search_index_control_query_request {
-    using response_type = search_index_control_query_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 = search_index_control_query_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::search;
+  static const inline service_type type = service_type::search;
 
-    std::string index_name;
-    bool allow;
+  std::string index_name;
+  bool allow;
 
-    std::optional<std::string> bucket_name;
-    std::optional<std::string> scope_name;
+  std::optional<std::string> bucket_name;
+  std::optional<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]] search_index_control_query_response make_response(error_context::http&& ctx, const encoded_response_type& encoded) const;
+  [[nodiscard]] search_index_control_query_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/search_index_drop.cxx

@@ -25,65 +25,68 @@
 namespace couchbase::core::operations::management
 {
 std::error_code
-search_index_drop_request::encode_to(encoded_request_type& encoded, http_context& /* context */) const
+search_index_drop_request::encode_to(encoded_request_type& encoded,
+                                     http_context& /* context */) const
 {
-    if (index_name.empty()) {
-        return errc::common::invalid_argument;
-    }
-    encoded.method = "DELETE";
-    if (bucket_name.has_value() && scope_name.has_value()) {
-        encoded.path = fmt::format("/api/bucket/{}/scope/{}/index/{}", bucket_name.value(), scope_name.value(), index_name);
-    } else {
-        encoded.path = fmt::format("/api/index/{}", index_name);
-    }
-    return {};
+  if (index_name.empty()) {
+    return errc::common::invalid_argument;
+  }
+  encoded.method = "DELETE";
+  if (bucket_name.has_value() && scope_name.has_value()) {
+    encoded.path = fmt::format(
+      "/api/bucket/{}/scope/{}/index/{}", bucket_name.value(), scope_name.value(), index_name);
+  } else {
+    encoded.path = fmt::format("/api/index/{}", index_name);
+  }
+  return {};
 }
 search_index_drop_response
-search_index_drop_request::make_response(error_context::http&& ctx, const encoded_response_type& encoded) const
+search_index_drop_request::make_response(error_context::http&& ctx,
+                                         const encoded_response_type& encoded) const
 {
-    search_index_drop_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;
-            }
-            response.status = payload.at("status").get_string();
-            if (response.status == "ok") {
-                return response;
-            }
-        } else if (encoded.status_code == 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.status = payload.at("status").get_string();
-            response.error = payload.at("error").get_string();
-            if (response.error.find("index not found") != std::string::npos) {
-                response.ctx.ec = errc::common::index_not_found;
-                return response;
-            }
-        } else if (encoded.status_code == 404) {
-            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();
-            response.error = payload.at("error").get_string();
-            response.ctx.ec = errc::common::feature_not_available;
-            return response;
-        }
-        response.ctx.ec = extract_common_error_code(encoded.status_code, encoded.body.data());
+  search_index_drop_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;
+      }
+      response.status = payload.at("status").get_string();
+      if (response.status == "ok") {
+        return response;
+      }
+    } else if (encoded.status_code == 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.status = payload.at("status").get_string();
+      response.error = payload.at("error").get_string();
+      if (response.error.find("index not found") != std::string::npos) {
+        response.ctx.ec = errc::common::index_not_found;
+        return response;
+      }
+    } else if (encoded.status_code == 404) {
+      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();
+      response.error = payload.at("error").get_string();
+      response.ctx.ec = errc::common::feature_not_available;
+      return response;
     }
-    return response;
+    response.ctx.ec = extract_common_error_code(encoded.status_code, encoded.body.data());
+  }
+  return response;
 }
 } // namespace couchbase::core::operations::management

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

@@ -26,29 +26,32 @@
 namespace couchbase::core::operations::management
 {
 struct search_index_drop_response {
-    error_context::http ctx;
-    std::string status{};
-    std::string error{};
+  error_context::http ctx;
+  std::string status{};
+  std::string error{};
 };
 
 struct search_index_drop_request {
-    using response_type = search_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 = search_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::search;
+  static const inline service_type type = service_type::search;
 
-    std::string index_name;
+  std::string index_name;
 
-    std::optional<std::string> bucket_name;
-    std::optional<std::string> scope_name;
+  std::optional<std::string> bucket_name;
+  std::optional<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]] search_index_drop_response make_response(error_context::http&& ctx, const encoded_response_type& encoded) const;
+  [[nodiscard]] search_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/search_index_get.cxx

@@ -26,67 +26,70 @@
 namespace couchbase::core::operations::management
 {
 std::error_code
-search_index_get_request::encode_to(encoded_request_type& encoded, http_context& /* context */) const
+search_index_get_request::encode_to(encoded_request_type& encoded,
+                                    http_context& /* context */) const
 {
-    if (index_name.empty()) {
-        return errc::common::invalid_argument;
-    }
-    encoded.method = "GET";
-    if (bucket_name.has_value() && scope_name.has_value()) {
-        encoded.path = fmt::format("/api/bucket/{}/scope/{}/index/{}", bucket_name.value(), scope_name.value(), index_name);
-    } else {
-        encoded.path = fmt::format("/api/index/{}", index_name);
-    }
-    return {};
+  if (index_name.empty()) {
+    return errc::common::invalid_argument;
+  }
+  encoded.method = "GET";
+  if (bucket_name.has_value() && scope_name.has_value()) {
+    encoded.path = fmt::format(
+      "/api/bucket/{}/scope/{}/index/{}", bucket_name.value(), scope_name.value(), index_name);
+  } else {
+    encoded.path = fmt::format("/api/index/{}", index_name);
+  }
+  return {};
 }
 
 search_index_get_response
-search_index_get_request::make_response(error_context::http&& ctx, const encoded_response_type& encoded) const
+search_index_get_request::make_response(error_context::http&& ctx,
+                                        const encoded_response_type& encoded) const
 {
-    search_index_get_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;
-            }
-            response.status = payload.at("status").get_string();
-            if (response.status == "ok") {
-                response.index = payload.at("indexDef").as<couchbase::core::management::search::index>();
-                return response;
-            }
-        } else if (encoded.status_code == 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.status = payload.at("status").get_string();
-            response.error = payload.at("error").get_string();
-            if (response.error.find("index not found") != std::string::npos) {
-                response.ctx.ec = errc::common::index_not_found;
-                return response;
-            }
-        } else if (encoded.status_code == 404) {
-            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();
-            response.error = payload.at("error").get_string();
-            response.ctx.ec = errc::common::feature_not_available;
-            return response;
-        }
-        response.ctx.ec = extract_common_error_code(encoded.status_code, encoded.body.data());
+  search_index_get_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;
+      }
+      response.status = payload.at("status").get_string();
+      if (response.status == "ok") {
+        response.index = payload.at("indexDef").as<couchbase::core::management::search::index>();
+        return response;
+      }
+    } else if (encoded.status_code == 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.status = payload.at("status").get_string();
+      response.error = payload.at("error").get_string();
+      if (response.error.find("index not found") != std::string::npos) {
+        response.ctx.ec = errc::common::index_not_found;
+        return response;
+      }
+    } else if (encoded.status_code == 404) {
+      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();
+      response.error = payload.at("error").get_string();
+      response.ctx.ec = errc::common::feature_not_available;
+      return response;
     }
-    return response;
+    response.ctx.ec = extract_common_error_code(encoded.status_code, encoded.body.data());
+  }
+  return response;
 }
 } // namespace couchbase::core::operations::management

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

@@ -27,30 +27,32 @@
 namespace couchbase::core::operations::management
 {
 struct search_index_get_response {
-    error_context::http ctx;
-    std::string status{};
-    couchbase::core::management::search::index index{};
-    std::string error{};
+  error_context::http ctx;
+  std::string status{};
+  couchbase::core::management::search::index index{};
+  std::string error{};
 };
 
 struct search_index_get_request {
-    using response_type = search_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 = search_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::search;
+  static const inline service_type type = service_type::search;
 
-    std::string index_name;
-    std::optional<std::string> bucket_name;
-    std::optional<std::string> scope_name;
+  std::string index_name;
+  std::optional<std::string> bucket_name;
+  std::optional<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]] search_index_get_response make_response(error_context::http&& ctx, const encoded_response_type& encoded) const;
+  [[nodiscard]] search_index_get_response make_response(error_context::http&& ctx,
+                                                        const encoded_response_type& encoded) const;
 };
 
 } // namespace couchbase::core::operations::management