couchbase 4.1.1 → 4.1.3

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

@@ -0,0 +1,130 @@
+/* -*- Mode: C++; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */
+/*
+ *   Copyright 2020-2021 Couchbase, Inc.
+ *
+ *   Licensed under the Apache License, Version 2.0 (the "License");
+ *   you may not use this file except in compliance with the License.
+ *   You may obtain a copy of the License at
+ *
+ *       http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *   Unless required by applicable law or agreed to in writing, software
+ *   distributed under the License is distributed on an "AS IS" BASIS,
+ *   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *   See the License for the specific language governing permissions and
+ *   limitations under the License.
+ */
+
+#include "bucket_update.hxx"
+
+#include "core/management/bucket_settings.hxx"
+#include "core/utils/join_strings.hxx"
+#include "core/utils/json.hxx"
+#include "error_utils.hxx"
+
+#include <couchbase/durability_level.hxx>
+
+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.headers["content-type"] = "application/x-www-form-urlencoded";
+    encoded.body.append(fmt::format("&ramQuotaMB={}", bucket.ram_quota_mb));
+    encoded.body.append(fmt::format("&replicaNumber={}", bucket.num_replicas));
+    if (bucket.max_expiry > 0) {
+        encoded.body.append(fmt::format("&maxTTL={}", bucket.max_expiry));
+    }
+    encoded.body.append(fmt::format("&replicaIndex={}", bucket.replica_indexes ? "1" : "0"));
+    encoded.body.append(fmt::format("&flushEnabled={}", bucket.flush_enabled ? "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;
+    }
+    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 {};
+}
+
+bucket_update_response
+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;
+        }
+    }
+    return response;
+}
+} // namespace couchbase::core::operations::management

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

@@ -0,0 +1,52 @@
+/* -*- Mode: C++; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */
+/*
+ *   Copyright 2020-2021 Couchbase, Inc.
+ *
+ *   Licensed under the Apache License, Version 2.0 (the "License");
+ *   you may not use this file except in compliance with the License.
+ *   You may obtain a copy of the License at
+ *
+ *       http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *   Unless required by applicable law or agreed to in writing, software
+ *   distributed under the License is distributed on an "AS IS" BASIS,
+ *   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *   See the License for the specific language governing permissions and
+ *   limitations under the License.
+ */
+
+#pragma once
+
+#include "core/error_context/http.hxx"
+#include "core/io/http_context.hxx"
+#include "core/io/http_message.hxx"
+#include "core/management/bucket_settings.hxx"
+#include "core/platform/uuid.h"
+#include "core/timeout_defaults.hxx"
+
+namespace couchbase::core::operations::management
+{
+struct bucket_update_response {
+    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;
+
+    static const inline service_type type = service_type::management;
+
+    couchbase::core::management::cluster::bucket_settings bucket{};
+
+    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]] 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/cluster_describe.cxx

@@ -0,0 +1,89 @@
+/* -*- Mode: C++; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */
+/*
+ *   Copyright 2021 Couchbase, Inc.
+ *
+ *   Licensed under the Apache License, Version 2.0 (the "License");
+ *   you may not use this file except in compliance with the License.
+ *   You may obtain a copy of the License at
+ *
+ *       http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *   Unless required by applicable law or agreed to in writing, software
+ *   distributed under the License is distributed on an "AS IS" BASIS,
+ *   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *   See the License for the specific language governing permissions and
+ *   limitations under the License.
+ */
+
+#include "cluster_describe.hxx"
+
+#include "core/utils/json.hxx"
+#include "error_utils.hxx"
+
+namespace couchbase::core::operations::management
+{
+std::error_code
+cluster_describe_request::encode_to(encoded_request_type& encoded, http_context& /* context */) const
+{
+    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_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());
+
+    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 (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;
+}
+} // namespace couchbase::core::operations::management

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

@@ -0,0 +1,72 @@
+/* -*- Mode: C++; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */
+/*
+ *   Copyright 2021 Couchbase, Inc.
+ *
+ *   Licensed under the Apache License, Version 2.0 (the "License");
+ *   you may not use this file except in compliance with the License.
+ *   You may obtain a copy of the License at
+ *
+ *       http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *   Unless required by applicable law or agreed to in writing, software
+ *   distributed under the License is distributed on an "AS IS" BASIS,
+ *   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *   See the License for the specific language governing permissions and
+ *   limitations under the License.
+ */
+
+#pragma once
+
+#include "core/error_context/http.hxx"
+#include "core/io/http_context.hxx"
+#include "core/io/http_message.hxx"
+#include "core/platform/uuid.h"
+#include "core/service_type.hxx"
+#include "core/timeout_defaults.hxx"
+
+#include <set>
+
+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{};
+        };
+
+        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;
+
+    static const inline service_type type = service_type::management;
+
+    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]] 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

@@ -0,0 +1,43 @@
+/* -*- Mode: C++; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */
+/*
+ *   Copyright 2020-2021 Couchbase, Inc.
+ *
+ *   Licensed under the Apache License, Version 2.0 (the "License");
+ *   you may not use this file except in compliance with the License.
+ *   You may obtain a copy of the License at
+ *
+ *       http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *   Unless required by applicable law or agreed to in writing, software
+ *   distributed under the License is distributed on an "AS IS" BASIS,
+ *   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *   See the License for the specific language governing permissions and
+ *   limitations under the License.
+ */
+
+#include "cluster_developer_preview_enable.hxx"
+
+#include "error_utils.hxx"
+
+namespace couchbase::core::operations::management
+{
+std::error_code
+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 {};
+}
+
+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_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

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

@@ -0,0 +1,48 @@
+/* -*- Mode: C++; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */
+/*
+ *   Copyright 2020-2021 Couchbase, Inc.
+ *
+ *   Licensed under the Apache License, Version 2.0 (the "License");
+ *   you may not use this file except in compliance with the License.
+ *   You may obtain a copy of the License at
+ *
+ *       http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *   Unless required by applicable law or agreed to in writing, software
+ *   distributed under the License is distributed on an "AS IS" BASIS,
+ *   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *   See the License for the specific language governing permissions and
+ *   limitations under the License.
+ */
+
+#pragma once
+
+#include "core/error_context/http.hxx"
+#include "core/io/http_context.hxx"
+#include "core/io/http_message.hxx"
+#include "core/platform/uuid.h"
+#include "core/timeout_defaults.hxx"
+
+namespace couchbase::core::operations::management
+{
+struct cluster_developer_preview_enable_response {
+    error_context::http ctx;
+};
+
+struct cluster_developer_preview_enable_request {
+    using response_type = cluster_developer_preview_enable_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;
+
+    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]] cluster_developer_preview_enable_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/collection_create.cxx

@@ -0,0 +1,82 @@
+/* -*- Mode: C++; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */
+/*
+ *   Copyright 2020-2021 Couchbase, Inc.
+ *
+ *   Licensed under the Apache License, Version 2.0 (the "License");
+ *   you may not use this file except in compliance with the License.
+ *   You may obtain a copy of the License at
+ *
+ *       http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *   Unless required by applicable law or agreed to in writing, software
+ *   distributed under the License is distributed on an "AS IS" BASIS,
+ *   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *   See the License for the specific language governing permissions and
+ *   limitations under the License.
+ */
+
+#include "collection_create.hxx"
+
+#include "core/utils/json.hxx"
+#include "core/utils/url_codec.hxx"
+#include "error_utils.hxx"
+
+#include <regex>
+
+namespace couchbase::core::operations::management
+{
+std::error_code
+collection_create_request::encode_to(encoded_request_type& encoded, http_context& /* context */) const
+{
+    encoded.method = "POST";
+    encoded.path = fmt::format("/pools/default/buckets/{}/scopes/{}/collections", bucket_name, scope_name);
+    encoded.headers["content-type"] = "application/x-www-form-urlencoded";
+    encoded.body = fmt::format("name={}", utils::string_codec::form_encode(collection_name));
+    if (max_expiry > 0) {
+        encoded.body.append(fmt::format("&maxTTL={}", max_expiry));
+    }
+    return {};
+}
+
+collection_create_response
+collection_create_request::make_response(error_context::http&& ctx, const encoded_response_type& encoded) const
+{
+    collection_create_response response{ std::move(ctx) };
+    if (!response.ctx.ec) {
+        switch (encoded.status_code) {
+            case 400: {
+                std::regex collection_exists("Collection with name .+ already exists");
+                if (std::regex_search(encoded.body.data(), collection_exists)) {
+                    response.ctx.ec = errc::management::collection_exists;
+                } else if (encoded.body.data().find("Not allowed on this version of cluster") != std::string::npos) {
+                    response.ctx.ec = errc::common::feature_not_available;
+                } else {
+                    response.ctx.ec = errc::common::invalid_argument;
+                }
+            } break;
+            case 404: {
+                std::regex scope_not_found("Scope with name .+ is not found");
+                if (std::regex_search(encoded.body.data(), scope_not_found)) {
+                    response.ctx.ec = errc::common::scope_not_found;
+                } else {
+                    response.ctx.ec = errc::common::bucket_not_found;
+                }
+            } break;
+            case 200: {
+                tao::json::value payload{};
+                try {
+                    payload = utils::json::parse(encoded.body.data());
+                } catch (const tao::pegtl::parse_error&) {
+                    response.ctx.ec = errc::common::parsing_failure;
+                    return response;
+                }
+                response.uid = std::stoull(payload.at("uid").get_string(), nullptr, 16);
+            } break;
+            default:
+                response.ctx.ec = extract_common_error_code(encoded.status_code, encoded.body.data());
+                break;
+        }
+    }
+    return response;
+}
+} // namespace couchbase::core::operations::management

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

@@ -0,0 +1,53 @@
+/* -*- Mode: C++; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */
+/*
+ *   Copyright 2020-2021 Couchbase, Inc.
+ *
+ *   Licensed under the Apache License, Version 2.0 (the "License");
+ *   you may not use this file except in compliance with the License.
+ *   You may obtain a copy of the License at
+ *
+ *       http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *   Unless required by applicable law or agreed to in writing, software
+ *   distributed under the License is distributed on an "AS IS" BASIS,
+ *   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *   See the License for the specific language governing permissions and
+ *   limitations under the License.
+ */
+
+#pragma once
+
+#include "core/error_context/http.hxx"
+#include "core/io/http_context.hxx"
+#include "core/io/http_message.hxx"
+#include "core/platform/uuid.h"
+#include "core/timeout_defaults.hxx"
+
+namespace couchbase::core::operations::management
+{
+struct collection_create_response {
+    error_context::http ctx;
+    std::uint64_t uid{ 0 };
+};
+
+struct collection_create_request {
+    using response_type = collection_create_response;
+    using encoded_request_type = io::http_request;
+    using encoded_response_type = io::http_response;
+    using error_context_type = error_context::http;
+
+    static const inline service_type type = service_type::management;
+
+    std::string bucket_name;
+    std::string scope_name;
+    std::string collection_name;
+    std::uint32_t max_expiry{ 0 };
+
+    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]] collection_create_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/collection_drop.cxx

@@ -0,0 +1,72 @@
+/* -*- Mode: C++; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */
+/*
+ *   Copyright 2020-2021 Couchbase, Inc.
+ *
+ *   Licensed under the Apache License, Version 2.0 (the "License");
+ *   you may not use this file except in compliance with the License.
+ *   You may obtain a copy of the License at
+ *
+ *       http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *   Unless required by applicable law or agreed to in writing, software
+ *   distributed under the License is distributed on an "AS IS" BASIS,
+ *   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *   See the License for the specific language governing permissions and
+ *   limitations under the License.
+ */
+
+#include "collection_drop.hxx"
+
+#include "core/utils/json.hxx"
+#include "error_utils.hxx"
+
+#include <regex>
+
+namespace couchbase::core::operations::management
+{
+std::error_code
+collection_drop_request::encode_to(encoded_request_type& encoded, http_context& /* context */) const
+{
+    encoded.method = "DELETE";
+    encoded.path = fmt::format("/pools/default/buckets/{}/scopes/{}/collections/{}", bucket_name, scope_name, collection_name);
+    return {};
+}
+
+collection_drop_response
+collection_drop_request::make_response(error_context::http&& ctx, const encoded_response_type& encoded) const
+{
+    collection_drop_response response{ std::move(ctx) };
+    if (!response.ctx.ec) {
+        switch (encoded.status_code) {
+            case 400:
+                response.ctx.ec = errc::common::unsupported_operation;
+                break;
+            case 404: {
+                std::regex scope_not_found("Scope with name .+ is not found");
+                std::regex collection_not_found("Collection with name .+ is not found");
+                if (std::regex_search(encoded.body.data(), collection_not_found)) {
+                    response.ctx.ec = errc::common::collection_not_found;
+                } else if (std::regex_search(encoded.body.data(), scope_not_found)) {
+                    response.ctx.ec = errc::common::scope_not_found;
+                } else {
+                    response.ctx.ec = errc::common::bucket_not_found;
+                }
+            } break;
+            case 200: {
+                tao::json::value payload{};
+                try {
+                    payload = utils::json::parse(encoded.body.data());
+                } catch (const tao::pegtl::parse_error&) {
+                    response.ctx.ec = errc::common::parsing_failure;
+                    return response;
+                }
+                response.uid = std::stoull(payload.at("uid").get_string(), nullptr, 16);
+            } break;
+            default:
+                response.ctx.ec = extract_common_error_code(encoded.status_code, encoded.body.data());
+                break;
+        }
+    }
+    return response;
+}
+} // namespace couchbase::core::operations::management