couchbase 4.3.1 → 4.4.1-dev.1

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

@@ -27,23 +27,25 @@
 namespace couchbase::core::operations::management
 {
 struct bucket_get_all_response {
-    error_context::http ctx;
-    std::vector<couchbase::core::management::cluster::bucket_settings> buckets{};
+  error_context::http ctx;
+  std::vector<couchbase::core::management::cluster::bucket_settings> buckets{};
 };
 
 struct bucket_get_all_request {
-    using response_type = bucket_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 = bucket_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]] bucket_get_all_response make_response(error_context::http&& ctx, const encoded_response_type& encoded) const;
+  [[nodiscard]] bucket_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/bucket_update.cxx

@@ -29,123 +29,128 @@ namespace couchbase::core::operations::management
 std::error_code
 bucket_update_request::encode_to(encoded_request_type& encoded, http_context& /* context */) const
 {
-    encoded.method = "POST";
-    encoded.path = fmt::format("/pools/default/buckets/{}", bucket.name);
+  encoded.method = "POST";
+  encoded.path = fmt::format("/pools/default/buckets/{}", bucket.name);
 
-    encoded.headers["content-type"] = "application/x-www-form-urlencoded";
+  encoded.headers["content-type"] = "application/x-www-form-urlencoded";
 
-    if (bucket.ram_quota_mb > 0) {
-        encoded.body.append(fmt::format("&ramQuotaMB={}", bucket.ram_quota_mb));
-    }
-    if (bucket.num_replicas.has_value()) {
-        encoded.body.append(fmt::format("&replicaNumber={}", bucket.num_replicas.value()));
-    }
+  if (bucket.ram_quota_mb > 0) {
+    encoded.body.append(fmt::format("&ramQuotaMB={}", bucket.ram_quota_mb));
+  }
+  if (bucket.num_replicas.has_value()) {
+    encoded.body.append(fmt::format("&replicaNumber={}", bucket.num_replicas.value()));
+  }
 
-    if (bucket.max_expiry.has_value()) {
-        encoded.body.append(fmt::format("&maxTTL={}", bucket.max_expiry.value()));
-    }
-    if (bucket.history_retention_collection_default.has_value()) {
-        encoded.body.append(
-          fmt::format("&historyRetentionCollectionDefault={}", bucket.history_retention_collection_default.value() ? "true" : "false"));
-    }
-    if (bucket.history_retention_bytes.has_value()) {
-        encoded.body.append(fmt::format("&historyRetentionBytes={}", bucket.history_retention_bytes.value()));
-    }
-    if (bucket.history_retention_duration.has_value()) {
-        encoded.body.append(fmt::format("&historyRetentionSeconds={}", bucket.history_retention_duration.value()));
-    }
-    if (bucket.replica_indexes.has_value()) {
-        encoded.body.append(fmt::format("&replicaIndex={}", bucket.replica_indexes.value() ? "1" : "0"));
-    }
-    if (bucket.flush_enabled.has_value()) {
-        encoded.body.append(fmt::format("&flushEnabled={}", bucket.flush_enabled.value() ? "1" : "0"));
-    }
+  if (bucket.max_expiry.has_value()) {
+    encoded.body.append(fmt::format("&maxTTL={}", bucket.max_expiry.value()));
+  }
+  if (bucket.history_retention_collection_default.has_value()) {
+    encoded.body.append(
+      fmt::format("&historyRetentionCollectionDefault={}",
+                  bucket.history_retention_collection_default.value() ? "true" : "false"));
+  }
+  if (bucket.history_retention_bytes.has_value()) {
+    encoded.body.append(
+      fmt::format("&historyRetentionBytes={}", bucket.history_retention_bytes.value()));
+  }
+  if (bucket.history_retention_duration.has_value()) {
+    encoded.body.append(
+      fmt::format("&historyRetentionSeconds={}", bucket.history_retention_duration.value()));
+  }
+  if (bucket.replica_indexes.has_value()) {
+    encoded.body.append(
+      fmt::format("&replicaIndex={}", bucket.replica_indexes.value() ? "1" : "0"));
+  }
+  if (bucket.flush_enabled.has_value()) {
+    encoded.body.append(fmt::format("&flushEnabled={}", bucket.flush_enabled.value() ? "1" : "0"));
+  }
 
-    switch (bucket.eviction_policy) {
-        case couchbase::core::management::cluster::bucket_eviction_policy::full:
-            encoded.body.append("&evictionPolicy=fullEviction");
-            break;
-        case couchbase::core::management::cluster::bucket_eviction_policy::value_only:
-            encoded.body.append("&evictionPolicy=valueOnly");
-            break;
-        case couchbase::core::management::cluster::bucket_eviction_policy::no_eviction:
-            encoded.body.append("&evictionPolicy=noEviction");
-            break;
-        case couchbase::core::management::cluster::bucket_eviction_policy::not_recently_used:
-            encoded.body.append("&evictionPolicy=nruEviction");
-            break;
-        case couchbase::core::management::cluster::bucket_eviction_policy::unknown:
-            break;
-    }
-    switch (bucket.compression_mode) {
-        case couchbase::core::management::cluster::bucket_compression::off:
-            encoded.body.append("&compressionMode=off");
-            break;
-        case couchbase::core::management::cluster::bucket_compression::active:
-            encoded.body.append("&compressionMode=active");
-            break;
-        case couchbase::core::management::cluster::bucket_compression::passive:
-            encoded.body.append("&compressionMode=passive");
-            break;
-        case couchbase::core::management::cluster::bucket_compression::unknown:
-            break;
+  switch (bucket.eviction_policy) {
+    case couchbase::core::management::cluster::bucket_eviction_policy::full:
+      encoded.body.append("&evictionPolicy=fullEviction");
+      break;
+    case couchbase::core::management::cluster::bucket_eviction_policy::value_only:
+      encoded.body.append("&evictionPolicy=valueOnly");
+      break;
+    case couchbase::core::management::cluster::bucket_eviction_policy::no_eviction:
+      encoded.body.append("&evictionPolicy=noEviction");
+      break;
+    case couchbase::core::management::cluster::bucket_eviction_policy::not_recently_used:
+      encoded.body.append("&evictionPolicy=nruEviction");
+      break;
+    case couchbase::core::management::cluster::bucket_eviction_policy::unknown:
+      break;
+  }
+  switch (bucket.compression_mode) {
+    case couchbase::core::management::cluster::bucket_compression::off:
+      encoded.body.append("&compressionMode=off");
+      break;
+    case couchbase::core::management::cluster::bucket_compression::active:
+      encoded.body.append("&compressionMode=active");
+      break;
+    case couchbase::core::management::cluster::bucket_compression::passive:
+      encoded.body.append("&compressionMode=passive");
+      break;
+    case couchbase::core::management::cluster::bucket_compression::unknown:
+      break;
+  }
+  if (bucket.minimum_durability_level) {
+    switch (bucket.minimum_durability_level.value()) {
+      case durability_level::none:
+        encoded.body.append("&durabilityMinLevel=none");
+        break;
+      case durability_level::majority:
+        encoded.body.append("&durabilityMinLevel=majority");
+        break;
+      case durability_level::majority_and_persist_to_active:
+        encoded.body.append("&durabilityMinLevel=majorityAndPersistActive");
+        break;
+      case durability_level::persist_to_majority:
+        encoded.body.append("&durabilityMinLevel=persistToMajority");
+        break;
     }
-    if (bucket.minimum_durability_level) {
-        switch (bucket.minimum_durability_level.value()) {
-            case durability_level::none:
-                encoded.body.append("&durabilityMinLevel=none");
-                break;
-            case durability_level::majority:
-                encoded.body.append("&durabilityMinLevel=majority");
-                break;
-            case durability_level::majority_and_persist_to_active:
-                encoded.body.append("&durabilityMinLevel=majorityAndPersistActive");
-                break;
-            case durability_level::persist_to_majority:
-                encoded.body.append("&durabilityMinLevel=persistToMajority");
-                break;
-        }
-    }
-    return {};
+  }
+  return {};
 }
 
 bucket_update_response
-bucket_update_request::make_response(error_context::http&& ctx, const encoded_response_type& encoded) const
+bucket_update_request::make_response(error_context::http&& ctx,
+                                     const encoded_response_type& encoded) const
 {
-    bucket_update_response response{ std::move(ctx) };
-    if (!response.ctx.ec) {
-        switch (encoded.status_code) {
-            case 404:
-                response.ctx.ec = errc::common::bucket_not_found;
-                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;
-                auto* errors = payload.find("errors");
-                if (errors != nullptr) {
-                    std::vector<std::string> error_list{};
-                    for (const auto& [field, message] : errors->get_object()) {
-                        error_list.emplace_back(message.get_string());
-                    }
-                    if (!error_list.empty()) {
-                        response.error_message = utils::join_strings(error_list, ". ");
-                    }
-                }
-            } break;
-            case 200:
-            case 202:
-                break;
-            default:
-                response.ctx.ec = extract_common_error_code(encoded.status_code, encoded.body.data());
-                break;
+  bucket_update_response response{ std::move(ctx) };
+  if (!response.ctx.ec) {
+    switch (encoded.status_code) {
+      case 404:
+        response.ctx.ec = errc::common::bucket_not_found;
+        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;
+        auto* errors = payload.find("errors");
+        if (errors != nullptr) {
+          std::vector<std::string> error_list{};
+          for (const auto& [field, message] : errors->get_object()) {
+            error_list.emplace_back(message.get_string());
+          }
+          if (!error_list.empty()) {
+            response.error_message = utils::join_strings(error_list, ". ");
+          }
         }
+      } break;
+      case 200:
+      case 202:
+        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/bucket_update.hxx

@@ -27,26 +27,28 @@
 namespace couchbase::core::operations::management
 {
 struct bucket_update_response {
-    error_context::http ctx;
-    couchbase::core::management::cluster::bucket_settings bucket{};
-    std::string error_message{};
+  error_context::http ctx;
+  couchbase::core::management::cluster::bucket_settings bucket{};
+  std::string error_message{};
 };
 
 struct bucket_update_request {
-    using response_type = bucket_update_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 = bucket_update_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::cluster::bucket_settings bucket{};
+  couchbase::core::management::cluster::bucket_settings bucket{};
 
-    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]] bucket_update_response make_response(error_context::http&& ctx, const encoded_response_type& encoded) const;
+  [[nodiscard]] bucket_update_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/change_password.cxx

@@ -26,32 +26,34 @@ namespace couchbase::core::operations::management
 std::error_code
 change_password_request::encode_to(encoded_request_type& encoded, http_context& /* context */) const
 {
-    encoded.method = "POST";
-    encoded.path = "/controller/changePassword";
-    encoded.headers["content-type"] = "application/x-www-form-urlencoded";
-    encoded.body = fmt::format("password={}", utils::string_codec::form_encode(newPassword));
+  encoded.method = "POST";
+  encoded.path = "/controller/changePassword";
+  encoded.headers["content-type"] = "application/x-www-form-urlencoded";
+  encoded.body = fmt::format("password={}", utils::string_codec::form_encode(newPassword));
 
-    return {};
+  return {};
 }
 
 change_password_response
-change_password_request::make_response(error_context::http&& ctx, const encoded_response_type& encoded) const
+change_password_request::make_response(error_context::http&& ctx,
+                                       const encoded_response_type& encoded) const
 {
-    change_password_response response{ std::move(ctx) };
-    if (!response.ctx.ec) {
-        switch (encoded.status_code) {
-            case 200:
-                break;
-            case 400:
-                if (encoded.body.data().find("Not allowed on this version of cluster") != std::string::npos) {
-                    response.ctx.ec = errc::common::feature_not_available;
-                }
-                break;
-            default:
-                response.ctx.ec = extract_common_error_code(encoded.status_code, encoded.body.data());
-                break;
+  change_password_response response{ std::move(ctx) };
+  if (!response.ctx.ec) {
+    switch (encoded.status_code) {
+      case 200:
+        break;
+      case 400:
+        if (encoded.body.data().find("Not allowed on this version of cluster") !=
+            std::string::npos) {
+          response.ctx.ec = errc::common::feature_not_available;
         }
+        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/change_password.hxx

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

@@ -23,67 +23,69 @@
 namespace couchbase::core::operations::management
 {
 std::error_code
-cluster_describe_request::encode_to(encoded_request_type& encoded, http_context& /* context */) const
+cluster_describe_request::encode_to(encoded_request_type& encoded,
+                                    http_context& /* context */) const
 {
-    encoded.method = "GET";
-    encoded.path = "/pools/default";
-    return {};
+  encoded.method = "GET";
+  encoded.path = "/pools/default";
+  return {};
 }
 
 cluster_describe_response
-cluster_describe_request::make_response(error_context::http&& ctx, const encoded_response_type& encoded) const
+cluster_describe_request::make_response(error_context::http&& ctx,
+                                        const encoded_response_type& encoded) const
 {
-    cluster_describe_response response{ std::move(ctx) };
-    if (!response.ctx.ec && encoded.status_code != 200) {
-        response.ctx.ec = extract_common_error_code(encoded.status_code, encoded.body.data());
-    }
-    if (response.ctx.ec) {
-        return response;
-    }
+  cluster_describe_response response{ std::move(ctx) };
+  if (!response.ctx.ec && encoded.status_code != 200) {
+    response.ctx.ec = extract_common_error_code(encoded.status_code, encoded.body.data());
+  }
+  if (response.ctx.ec) {
+    return response;
+  }
 
-    auto payload = utils::json::parse(encoded.body.data());
+  auto payload = utils::json::parse(encoded.body.data());
 
-    if (auto* nodes = payload.find("nodes"); nodes != nullptr && nodes->is_array()) {
-        for (auto& node : nodes->get_array()) {
-            cluster_describe_response::cluster_info::node entry{};
-            entry.hostname = node.at("hostname").get_string();
-            entry.otp_node = node.at("otpNode").get_string();
-            if (auto* uuid = node.find("nodeUUID"); uuid != nullptr && uuid->is_string()) {
-                entry.uuid = uuid->get_string();
-            }
-            entry.version = node.at("version").get_string();
-            entry.os = node.at("os").get_string();
-            entry.status = node.at("status").get_string();
-            if (auto* services = node.find("services"); services != nullptr && services->is_array()) {
-                for (auto& service : services->get_array()) {
-                    auto& service_string = service.get_string();
-                    entry.services.emplace_back(service_string);
+  if (auto* nodes = payload.find("nodes"); nodes != nullptr && nodes->is_array()) {
+    for (auto& node : nodes->get_array()) {
+      cluster_describe_response::cluster_info::node entry{};
+      entry.hostname = node.at("hostname").get_string();
+      entry.otp_node = node.at("otpNode").get_string();
+      if (auto* uuid = node.find("nodeUUID"); uuid != nullptr && uuid->is_string()) {
+        entry.uuid = uuid->get_string();
+      }
+      entry.version = node.at("version").get_string();
+      entry.os = node.at("os").get_string();
+      entry.status = node.at("status").get_string();
+      if (auto* services = node.find("services"); services != nullptr && services->is_array()) {
+        for (auto& service : services->get_array()) {
+          auto& service_string = service.get_string();
+          entry.services.emplace_back(service_string);
 
-                    if (service_string == "cbas") {
-                        response.info.services.insert(service_type::analytics);
-                    } else if (service_string == "fts") {
-                        response.info.services.insert(service_type::search);
-                    } else if (service_string == "n1ql") {
-                        response.info.services.insert(service_type::query);
-                    } else if (service_string == "kv") {
-                        response.info.services.insert(service_type::key_value);
-                    } else if (service_string == "eventing") {
-                        response.info.services.insert(service_type::eventing);
-                    }
-                }
-            }
-            response.info.nodes.emplace_back(entry);
+          if (service_string == "cbas") {
+            response.info.services.insert(service_type::analytics);
+          } else if (service_string == "fts") {
+            response.info.services.insert(service_type::search);
+          } else if (service_string == "n1ql") {
+            response.info.services.insert(service_type::query);
+          } else if (service_string == "kv") {
+            response.info.services.insert(service_type::key_value);
+          } else if (service_string == "eventing") {
+            response.info.services.insert(service_type::eventing);
+          }
         }
+      }
+      response.info.nodes.emplace_back(entry);
     }
-    if (auto* buckets = payload.find("bucketNames"); buckets != nullptr && buckets->is_array()) {
-        for (auto& node : buckets->get_array()) {
-            cluster_describe_response::cluster_info::bucket entry{};
-            entry.name = node.at("bucketName").get_string();
-            entry.uuid = node.at("uuid").get_string();
-            response.info.buckets.emplace_back(entry);
-        }
+  }
+  if (auto* buckets = payload.find("bucketNames"); buckets != nullptr && buckets->is_array()) {
+    for (auto& node : buckets->get_array()) {
+      cluster_describe_response::cluster_info::bucket entry{};
+      entry.name = node.at("bucketName").get_string();
+      entry.uuid = node.at("uuid").get_string();
+      response.info.buckets.emplace_back(entry);
     }
+  }
 
-    return response;
+  return response;
 }
 } // namespace couchbase::core::operations::management

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

@@ -29,44 +29,46 @@
 namespace couchbase::core::operations::management
 {
 struct cluster_describe_response {
-    struct cluster_info {
-        struct node {
-            std::string uuid{};
-            std::string otp_node{};
-            std::string status{};
-            std::string hostname{};
-            std::string os{};
-            std::string version{};
-            std::vector<std::string> services{};
-        };
-
-        struct bucket {
-            std::string uuid{};
-            std::string name{};
-        };
+  struct cluster_info {
+    struct node {
+      std::string uuid{};
+      std::string otp_node{};
+      std::string status{};
+      std::string hostname{};
+      std::string os{};
+      std::string version{};
+      std::vector<std::string> services{};
+    };
 
-        std::vector<node> nodes{};
-        std::vector<bucket> buckets{};
-        std::set<service_type> services{};
+    struct bucket {
+      std::string uuid{};
+      std::string name{};
     };
 
-    error_context::http ctx;
-    cluster_info info{};
+    std::vector<node> nodes{};
+    std::vector<bucket> buckets{};
+    std::set<service_type> services{};
+  };
+
+  error_context::http ctx;
+  cluster_info info{};
 };
 
 struct cluster_describe_request {
-    using response_type = cluster_describe_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 = cluster_describe_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]] cluster_describe_response make_response(error_context::http&& ctx, const encoded_response_type& encoded) const;
+  [[nodiscard]] cluster_describe_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/cluster_developer_preview_enable.cxx

@@ -22,22 +22,24 @@
 namespace couchbase::core::operations::management
 {
 std::error_code
-cluster_developer_preview_enable_request::encode_to(encoded_request_type& encoded, http_context& /* context */) const
+cluster_developer_preview_enable_request::encode_to(encoded_request_type& encoded,
+                                                    http_context& /* context */) const
 {
-    encoded.method = "POST";
-    encoded.headers["content-type"] = "application/x-www-form-urlencoded";
-    encoded.path = "/settings/developerPreview";
-    encoded.body = "enabled=true";
-    return {};
+  encoded.method = "POST";
+  encoded.headers["content-type"] = "application/x-www-form-urlencoded";
+  encoded.path = "/settings/developerPreview";
+  encoded.body = "enabled=true";
+  return {};
 }
 
 cluster_developer_preview_enable_response
-cluster_developer_preview_enable_request::make_response(error_context::http&& ctx, const encoded_response_type& encoded) const
+cluster_developer_preview_enable_request::make_response(error_context::http&& ctx,
+                                                        const encoded_response_type& encoded) const
 {
-    cluster_developer_preview_enable_response response{ std::move(ctx) };
-    if (!response.ctx.ec && encoded.status_code != 200) {
-        response.ctx.ec = extract_common_error_code(encoded.status_code, encoded.body.data());
-    }
-    return response;
+  cluster_developer_preview_enable_response response{ std::move(ctx) };
+  if (!response.ctx.ec && encoded.status_code != 200) {
+    response.ctx.ec = extract_common_error_code(encoded.status_code, encoded.body.data());
+  }
+  return response;
 }
 } // namespace couchbase::core::operations::management