couchbase 4.1.2 → 4.1.3

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

@@ -0,0 +1,79 @@
+/* -*- 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 "analytics_index_get_all.hxx"
+
+#include "core/utils/json.hxx"
+#include "error_utils.hxx"
+
+namespace couchbase::core::operations::management
+{
+std::error_code
+analytics_index_get_all_request::encode_to(encoded_request_type& encoded, http_context& /* context */) const
+{
+    tao::json::value body{
+        { "statement", "SELECT d.* FROM Metadata.`Index` d WHERE d.DataverseName <> \"Metadata\"" },
+    };
+
+    encoded.headers["content-type"] = "application/json";
+    encoded.method = "POST";
+    encoded.path = "/analytics/service";
+    encoded.body = utils::json::generate(body);
+    return {};
+}
+
+analytics_index_get_all_response
+analytics_index_get_all_request::make_response(error_context::http&& ctx, const encoded_response_type& encoded) const
+{
+    analytics_index_get_all_response response{ std::move(ctx) };
+
+    if (!response.ctx.ec) {
+        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.optional<std::string>("status").value_or("unknown");
+        if (response.status == "success") {
+            if (auto* results = payload.find("results"); results != nullptr && results->is_array()) {
+                for (const auto& res : results->get_array()) {
+                    couchbase::core::management::analytics::index idx;
+                    idx.name = res.at("IndexName").get_string();
+                    idx.dataverse_name = res.at("DataverseName").get_string();
+                    idx.dataset_name = res.at("DatasetName").get_string();
+                    idx.is_primary = res.at("IsPrimary").get_boolean();
+                    response.indexes.emplace_back(idx);
+                }
+            }
+        } else {
+            if (auto* errors = payload.find("errors"); errors != nullptr && errors->is_array()) {
+                for (const auto& error : errors->get_array()) {
+                    analytics_problem err{
+                        error.at("code").as<std::uint32_t>(),
+                        error.at("msg").get_string(),
+                    };
+                    response.errors.emplace_back(err);
+                }
+            }
+            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/analytics_index_get_all.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 "analytics_problem.hxx"
+#include "core/error_context/http.hxx"
+#include "core/io/http_context.hxx"
+#include "core/io/http_message.hxx"
+#include "core/management/analytics_index.hxx"
+#include "core/platform/uuid.h"
+#include "core/timeout_defaults.hxx"
+
+namespace couchbase::core::operations::management
+{
+struct analytics_index_get_all_response {
+    error_context::http ctx;
+    std::string status{};
+    std::vector<couchbase::core::management::analytics::index> indexes{};
+    std::vector<analytics_problem> errors{};
+};
+
+struct analytics_index_get_all_request {
+    using response_type = analytics_index_get_all_response;
+    using encoded_request_type = io::http_request;
+    using encoded_response_type = io::http_response;
+    using error_context_type = error_context::http;
+
+    static const inline service_type type = service_type::analytics;
+
+    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]] analytics_index_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/analytics_link_connect.cxx

@@ -0,0 +1,81 @@
+/* -*- 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 "analytics_link_connect.hxx"
+
+#include "core/utils/json.hxx"
+#include "core/utils/name_codec.hxx"
+#include "error_utils.hxx"
+
+namespace couchbase::core::operations::management
+{
+std::error_code
+analytics_link_connect_request::encode_to(encoded_request_type& encoded, http_context& /* context */) const
+{
+    std::string with_clause = force ? "WITH {\"force\": true}" : "";
+
+    tao::json::value body{
+        { "statement", fmt::format("CONNECT LINK {}.`{}` {}", utils::analytics::uncompound_name(dataverse_name), link_name, with_clause) },
+    };
+    encoded.headers["content-type"] = "application/json";
+    encoded.method = "POST";
+    encoded.path = "/analytics/service";
+    encoded.body = utils::json::generate(body);
+    return {};
+}
+
+analytics_link_connect_response
+analytics_link_connect_request::make_response(error_context::http&& ctx, const encoded_response_type& encoded) const
+{
+    analytics_link_connect_response response{ std::move(ctx) };
+    if (!response.ctx.ec) {
+        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.optional<std::string>("status").value_or("unknown");
+
+        if (response.status != "success") {
+            bool link_not_found = false;
+
+            if (auto* errors = payload.find("errors"); errors != nullptr && errors->is_array()) {
+                for (const auto& error : errors->get_array()) {
+                    analytics_link_connect_response::problem err{
+                        error.at("code").as<std::uint32_t>(),
+                        error.at("msg").get_string(),
+                    };
+                    switch (err.code) {
+                        case 24006: /* Link [string] does not exist */
+                            link_not_found = true;
+                            break;
+                    }
+                    response.errors.emplace_back(err);
+                }
+            }
+            if (link_not_found) {
+                response.ctx.ec = errc::analytics::link_not_found;
+            } else {
+                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/analytics_link_connect.hxx

@@ -0,0 +1,57 @@
+/* -*- 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 analytics_link_connect_response {
+    struct problem {
+        std::uint32_t code;
+        std::string message;
+    };
+
+    error_context::http ctx;
+    std::string status{};
+    std::vector<problem> errors{};
+};
+
+struct analytics_link_connect_request {
+    using response_type = analytics_link_connect_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::analytics;
+
+    std::string dataverse_name{ "Default" };
+    std::string link_name{ "Local" };
+    bool force{ false };
+    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]] analytics_link_connect_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/analytics_link_create.cxx

@@ -0,0 +1,86 @@
+/* -*- 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 "analytics_link_create.hxx"
+
+#include "core/utils/json.hxx"
+#include "core/utils/name_codec.hxx"
+#include "error_utils.hxx"
+
+namespace couchbase::core::operations::management
+{
+namespace details
+{
+analytics_link_create_response
+make_analytics_link_create_response(error_context::http&& ctx, const io::http_response& encoded)
+{
+    management::analytics_link_create_response response{ std::move(ctx) };
+    if (!response.ctx.ec) {
+        if (encoded.body.data().empty() && response.ctx.http_status == 200) {
+            return response;
+        }
+        tao::json::value payload{};
+        try {
+            payload = utils::json::parse(encoded.body.data());
+        } catch (const tao::pegtl::parse_error&) {
+            auto colon = encoded.body.data().find(':');
+            if (colon == std::string::npos) {
+                response.ctx.ec = errc::common::parsing_failure;
+                return response;
+            }
+            auto code = static_cast<std::uint32_t>(std::stoul(encoded.body.data()));
+            auto msg = encoded.body.data().substr(colon + 1);
+            response.errors.emplace_back(management::analytics_link_create_response::problem{ code, msg });
+        }
+        if (payload.is_object()) {
+            response.status = payload.optional<std::string>("status").value_or("unknown");
+            if (response.status != "success") {
+                if (auto* errors = payload.find("errors"); errors != nullptr && errors->is_array()) {
+                    for (const auto& error : errors->get_array()) {
+                        management::analytics_link_create_response::problem err{
+                            error.at("code").as<std::uint32_t>(),
+                            error.at("msg").get_string(),
+                        };
+                        response.errors.emplace_back(err);
+                    }
+                }
+            }
+        }
+        bool link_exists = false;
+        bool dataverse_does_not_exist = false;
+        for (const auto& err : response.errors) {
+            switch (err.code) {
+                case 24055: /* Link [string] already exists */
+                    link_exists = true;
+                    break;
+                case 24034: /* Cannot find dataverse with name [string] */
+                    dataverse_does_not_exist = true;
+                    break;
+            }
+        }
+        if (dataverse_does_not_exist) {
+            response.ctx.ec = errc::analytics::dataverse_not_found;
+        } else if (link_exists) {
+            response.ctx.ec = errc::analytics::link_exists;
+        } else {
+            response.ctx.ec = extract_common_error_code(encoded.status_code, encoded.body.data());
+        }
+    }
+    return response;
+}
+} // namespace details
+} // namespace couchbase::core::operations::management

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

@@ -0,0 +1,77 @@
+/* -*- 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 "analytics_link_utils.hxx"
+#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 analytics_link_create_response {
+    struct problem {
+        std::uint32_t code;
+        std::string message;
+    };
+
+    error_context::http ctx;
+    std::string status{};
+    std::vector<problem> errors{};
+};
+
+namespace details
+{
+analytics_link_create_response
+make_analytics_link_create_response(error_context::http&& ctx, const io::http_response& encoded);
+} // namespace details
+
+template<typename analytics_link_type>
+struct analytics_link_create_request {
+    using response_type = analytics_link_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::analytics;
+
+    analytics_link_type link{};
+    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
+    {
+        if (std::error_code ec = link.validate(); ec) {
+            return ec;
+        }
+        encoded.headers["content-type"] = "application/x-www-form-urlencoded";
+        encoded.headers["accept"] = "application/json";
+        encoded.method = "POST";
+        encoded.path = endpoint_from_analytics_link(link);
+        encoded.body = link.encode();
+        return {};
+    }
+
+    [[nodiscard]] analytics_link_create_response make_response(error_context::http&& ctx, const encoded_response_type& encoded) const
+    {
+        return details::make_analytics_link_create_response(std::move(ctx), encoded);
+    }
+};
+} // namespace couchbase::core::operations::management

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

@@ -0,0 +1,79 @@
+/* -*- 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 "analytics_link_disconnect.hxx"
+
+#include "core/utils/json.hxx"
+#include "core/utils/name_codec.hxx"
+#include "error_utils.hxx"
+
+namespace couchbase::core::operations::management
+{
+std::error_code
+analytics_link_disconnect_request::encode_to(encoded_request_type& encoded, http_context& /* context */) const
+{
+    tao::json::value body{
+        { "statement", fmt::format("DISCONNECT LINK {}.`{}`", utils::analytics::uncompound_name(dataverse_name), link_name) },
+    };
+    encoded.headers["content-type"] = "application/json";
+    encoded.method = "POST";
+    encoded.path = "/analytics/service";
+    encoded.body = utils::json::generate(body);
+    return {};
+}
+
+analytics_link_disconnect_response
+analytics_link_disconnect_request::make_response(error_context::http&& ctx, const encoded_response_type& encoded) const
+{
+    analytics_link_disconnect_response response{ std::move(ctx) };
+    if (!response.ctx.ec) {
+        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.optional<std::string>("status").value_or("unknown");
+
+        if (response.status != "success") {
+            bool link_not_found = false;
+
+            if (auto* errors = payload.find("errors"); errors != nullptr && errors->is_array()) {
+                for (const auto& error : errors->get_array()) {
+                    analytics_link_disconnect_response::problem err{
+                        error.at("code").as<std::uint32_t>(),
+                        error.at("msg").get_string(),
+                    };
+                    switch (err.code) {
+                        case 24006: /* Link [string] does not exist */
+                            link_not_found = true;
+                            break;
+                    }
+                    response.errors.emplace_back(err);
+                }
+            }
+            if (link_not_found) {
+                response.ctx.ec = errc::analytics::link_not_found;
+            } else {
+                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/analytics_link_disconnect.hxx

@@ -0,0 +1,56 @@
+/* -*- 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 analytics_link_disconnect_response {
+    struct problem {
+        std::uint32_t code;
+        std::string message;
+    };
+
+    error_context::http ctx;
+    std::string status{};
+    std::vector<problem> errors{};
+};
+
+struct analytics_link_disconnect_request {
+    using response_type = analytics_link_disconnect_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::analytics;
+
+    std::string dataverse_name{ "Default" };
+    std::string link_name{ "Local" };
+    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]] analytics_link_disconnect_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/analytics_link_drop.cxx

@@ -0,0 +1,102 @@
+/* -*- 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 "analytics_link_drop.hxx"
+
+#include "core/utils/json.hxx"
+#include "core/utils/url_codec.hxx"
+#include "error_utils.hxx"
+
+namespace couchbase::core::operations::management
+{
+std::error_code
+analytics_link_drop_request::encode_to(encoded_request_type& encoded, http_context& /* context */) const
+{
+    encoded.headers["content-type"] = "application/x-www-form-urlencoded";
+    encoded.headers["accept"] = "application/json";
+    encoded.method = "DELETE";
+    if (std::count(dataverse_name.begin(), dataverse_name.end(), '/') == 0) {
+        std::map<std::string, std::string> values{
+            { "dataverse", dataverse_name },
+            { "name", link_name },
+        };
+        encoded.body = utils::string_codec::v2::form_encode(values);
+        encoded.path = "/analytics/link";
+    } else {
+        encoded.path = fmt::format("/analytics/link/{}/{}", utils::string_codec::v2::path_escape(dataverse_name), link_name);
+    }
+    return {};
+}
+
+analytics_link_drop_response
+analytics_link_drop_request::make_response(error_context::http&& ctx, const encoded_response_type& encoded) const
+{
+    analytics_link_drop_response response{ std::move(ctx) };
+    if (!response.ctx.ec) {
+        if (encoded.body.data().empty() && response.ctx.http_status == 200) {
+            return response;
+        }
+        tao::json::value payload{};
+        try {
+            payload = utils::json::parse(encoded.body.data());
+        } catch (const tao::pegtl::parse_error&) {
+            auto colon = encoded.body.data().find(':');
+            if (colon == std::string::npos) {
+                response.ctx.ec = errc::common::parsing_failure;
+                return response;
+            }
+            auto code = static_cast<std::uint32_t>(std::stoul(encoded.body.data()));
+            auto msg = encoded.body.data().substr(colon + 1);
+            response.errors.emplace_back(analytics_link_drop_response::problem{ code, msg });
+        }
+        if (payload.is_object()) {
+            response.status = payload.optional<std::string>("status").value_or("unknown");
+            if (response.status != "success") {
+                if (auto* errors = payload.find("errors"); errors != nullptr && errors->is_array()) {
+                    for (const auto& error : errors->get_array()) {
+                        analytics_link_drop_response::problem err{
+                            error.at("code").as<std::uint32_t>(),
+                            error.at("msg").get_string(),
+                        };
+                        response.errors.emplace_back(err);
+                    }
+                }
+            }
+        }
+        bool link_not_found = false;
+        bool dataverse_does_not_exist = false;
+        for (const auto& err : response.errors) {
+            switch (err.code) {
+                case 24006: /* Link [string] does not exist */
+                    link_not_found = true;
+                    break;
+                case 24034: /* Cannot find dataverse with name [string] */
+                    dataverse_does_not_exist = true;
+                    break;
+            }
+        }
+        if (dataverse_does_not_exist) {
+            response.ctx.ec = errc::analytics::dataverse_not_found;
+        } else if (link_not_found) {
+            response.ctx.ec = errc::analytics::link_not_found;
+        } else {
+            response.ctx.ec = extract_common_error_code(encoded.status_code, encoded.body.data());
+        }
+    }
+    return response;
+}
+} // namespace couchbase::core::operations::management