couchbase 4.1.2 → 4.1.3

package/deps/couchbase-transactions-cxx/deps/couchbase-cxx-client/core/operations/management/query_index_create.cxx

@@ -0,0 +1,148 @@
+/* -*- 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 "query_index_create.hxx"
+
+#include "core/utils/join_strings.hxx"
+#include "core/utils/json.hxx"
+#include "error_utils.hxx"
+
+namespace couchbase::core::operations::management
+{
+std::error_code
+query_index_create_request::encode_to(encoded_request_type& encoded, http_context&) const
+{
+    if ((scope_name.empty() && !collection_name.empty()) || (!scope_name.empty() && collection_name.empty())) {
+        return errc::common::invalid_argument;
+    }
+    encoded.headers["content-type"] = "application/json";
+    tao::json::value with{};
+    if (deferred) {
+        with["defer_build"] = *deferred;
+    }
+    if (num_replicas) {
+        with["num_replica"] = *num_replicas; /* no 's' in key name */
+    }
+    std::string where_clause{};
+    if (condition) {
+        where_clause = fmt::format("WHERE {}", *condition);
+    }
+    std::string with_clause{};
+    if (with) {
+        with_clause = fmt::format("WITH {}", utils::json::generate(with));
+    }
+    std::string keyspace = fmt::format("{}:`{}`", namespace_id, bucket_name);
+    if (!scope_name.empty()) {
+        keyspace += ".`" + scope_name + "`";
+    }
+    if (!collection_name.empty()) {
+        keyspace += ".`" + collection_name + "`";
+    }
+    tao::json::value body{ { "statement",
+                             is_primary ? fmt::format(R"(CREATE PRIMARY INDEX {} ON {} USING GSI {})",
+                                                      index_name.empty() ? "" : fmt::format("`{}`", index_name),
+                                                      keyspace,
+                                                      with_clause)
+                                        : fmt::format(R"(CREATE INDEX `{}` ON {}({}) {} USING GSI {})",
+                                                      index_name,
+                                                      keyspace,
+                                                      utils::join_strings(fields, ", "),
+                                                      where_clause,
+                                                      with_clause) },
+                           { "client_context_id", encoded.client_context_id } };
+    encoded.method = "POST";
+    encoded.path = "/query/service";
+    encoded.body = utils::json::generate(body);
+    return {};
+}
+
+query_index_create_response
+query_index_create_request::make_response(error_context::http&& ctx, const encoded_response_type& encoded) const
+{
+    query_index_create_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.at("status").get_string();
+
+        if (response.status != "success") {
+            bool index_already_exists = false;
+            bool bucket_not_found = false;
+            bool collection_not_found = false;
+            bool scope_not_found = false;
+            std::optional<std::error_code> common_ec{};
+            for (const auto& entry : payload.at("errors").get_array()) {
+                query_index_create_response::query_problem error;
+                error.code = entry.at("code").get_unsigned();
+                error.message = entry.at("msg").get_string();
+                switch (error.code) {
+                    case 5000: /* IKey: "Internal Error" */
+                        if (error.message.find(" already exists") != std::string::npos) {
+                            index_already_exists = true;
+                        }
+                        if (error.message.find("Bucket Not Found") != std::string::npos) {
+                            bucket_not_found = true;
+                        }
+                        break;
+
+                    case 12003: /* IKey: "datastore.couchbase.keyspace_not_found" */
+                        if (error.message.find("missing_collection") != std::string::npos) {
+                            collection_not_found = true;
+                        } else {
+                            bucket_not_found = true;
+                        }
+                        break;
+
+                    case 12021:
+                        scope_not_found = true;
+                        break;
+
+                    case 4300: /* IKey: "plan.new_index_already_exists" */
+                        index_already_exists = true;
+                        break;
+
+                    default:
+                        common_ec = management::extract_common_query_error_code(error.code, error.message);
+                        break;
+                }
+                response.errors.emplace_back(error);
+            }
+            if (index_already_exists) {
+                if (!ignore_if_exists) {
+                    response.ctx.ec = errc::common::index_exists;
+                }
+            } else if (bucket_not_found) {
+                response.ctx.ec = errc::common::bucket_not_found;
+            } else if (collection_not_found) {
+                response.ctx.ec = errc::common::collection_not_found;
+            } else if (scope_not_found) {
+                response.ctx.ec = errc::common::scope_not_found;
+            } else if (common_ec) {
+                response.ctx.ec = common_ec.value();
+            } else if (!response.errors.empty()) {
+                response.ctx.ec = extract_common_error_code(encoded.status_code, encoded.body.data());
+            }
+        }
+    }
+    return response;
+}
+} // namespace couchbase::core::operations::management

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

@@ -0,0 +1,65 @@
+/* -*- 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 query_index_create_response {
+    struct query_problem {
+        std::uint64_t code;
+        std::string message;
+    };
+    error_context::http ctx;
+    std::string status{};
+    std::vector<query_problem> errors{};
+};
+
+struct query_index_create_request {
+    using response_type = query_index_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::query;
+
+    static constexpr auto namespace_id = "default";
+    std::string bucket_name;
+    std::string scope_name;
+    std::string collection_name;
+    std::string index_name{};
+    std::vector<std::string> fields;
+    bool is_primary{ false };
+    bool ignore_if_exists{ false };
+    std::optional<std::string> condition{};
+    std::optional<bool> deferred{};
+    std::optional<int> num_replicas{};
+
+    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]] query_index_create_response make_response(error_context::http&& ctx, const encoded_response_type& encoded) const;
+};
+} // namespace couchbase::core::operations::management

package/deps/couchbase-transactions-cxx/deps/couchbase-cxx-client/core/operations/management/query_index_drop.cxx

@@ -0,0 +1,128 @@
+/* -*- 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 "query_index_drop.hxx"
+
+#include "core/utils/json.hxx"
+#include "error_utils.hxx"
+
+namespace couchbase::core::operations::management
+{
+std::error_code
+query_index_drop_request::encode_to(encoded_request_type& encoded, http_context& /* context */) const
+{
+    if ((scope_name.empty() && !collection_name.empty()) || (!scope_name.empty() && collection_name.empty())) {
+        return errc::common::invalid_argument;
+    }
+    encoded.headers["content-type"] = "application/json";
+    std::string keyspace = fmt::format("`{}`", bucket_name);
+    if (!scope_name.empty()) {
+        keyspace += ".`" + scope_name + "`";
+    }
+    if (!collection_name.empty()) {
+        keyspace += ".`" + collection_name + "`";
+    }
+
+    std::string drop_index_stmt;
+    if (is_primary && index_name.empty()) {
+        drop_index_stmt = fmt::format(R"(DROP PRIMARY INDEX ON {} USING GSI)", keyspace);
+    } else if (!scope_name.empty() || !collection_name.empty()) {
+        drop_index_stmt = fmt::format(R"(DROP INDEX `{}` ON {} USING GSI)", index_name, keyspace);
+    } else {
+        drop_index_stmt = fmt::format(R"(DROP INDEX {}.`{}` USING GSI)", keyspace, index_name);
+    }
+    tao::json::value body{ { "statement", drop_index_stmt }, { "client_context_id", encoded.client_context_id } };
+    encoded.method = "POST";
+    encoded.path = "/query/service";
+    encoded.body = utils::json::generate(body);
+    return {};
+}
+
+query_index_drop_response
+query_index_drop_request::make_response(error_context::http&& ctx, const encoded_response_type& encoded) const
+{
+    query_index_drop_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.at("status").get_string();
+
+        if (response.status != "success") {
+            bool bucket_not_found = false;
+            bool index_not_found = false;
+            bool collection_not_found = false;
+            bool scope_not_found = false;
+            std::optional<std::error_code> common_ec{};
+            for (const auto& entry : payload.at("errors").get_array()) {
+                query_index_drop_response::query_problem error;
+                error.code = entry.at("code").get_unsigned();
+                error.message = entry.at("msg").get_string();
+                switch (error.code) {
+                    case 5000: /* IKey: "Internal Error" */
+                        if (error.message.find("not found.") != std::string::npos) {
+                            index_not_found = true;
+                        }
+                        break;
+
+                    case 12003: /* IKey: "datastore.couchbase.keyspace_not_found" */
+                        if (error.message.find("missing_collection") != std::string::npos) {
+                            collection_not_found = true;
+                        } else {
+                            bucket_not_found = true;
+                        }
+                        break;
+
+                    case 12021:
+                        scope_not_found = true;
+                        break;
+
+                    case 12004: /* IKey: "datastore.couchbase.primary_idx_not_found" */
+                    case 12016: /* IKey: "datastore.couchbase.index_not_found" */
+                        index_not_found = true;
+                        break;
+
+                    default:
+                        common_ec = management::extract_common_query_error_code(error.code, error.message);
+                        break;
+                }
+                response.errors.emplace_back(error);
+            }
+            if (index_not_found) {
+                if (!ignore_if_does_not_exist) {
+                    response.ctx.ec = errc::common::index_not_found;
+                }
+            } else if (bucket_not_found) {
+                response.ctx.ec = errc::common::bucket_not_found;
+            } else if (collection_not_found) {
+                response.ctx.ec = errc::common::collection_not_found;
+            } else if (scope_not_found) {
+                response.ctx.ec = errc::common::scope_not_found;
+            } else if (common_ec) {
+                response.ctx.ec = common_ec.value();
+            } else if (!response.errors.empty()) {
+                response.ctx.ec = extract_common_error_code(encoded.status_code, encoded.body.data());
+            }
+        }
+    }
+    return response;
+}
+} // namespace couchbase::core::operations::management

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

@@ -0,0 +1,61 @@
+/* -*- 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 query_index_drop_response {
+    struct query_problem {
+        std::uint64_t code;
+        std::string message;
+    };
+    error_context::http ctx;
+    std::string status{};
+    std::vector<query_problem> errors{};
+};
+
+struct query_index_drop_request {
+    using response_type = query_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::query;
+
+    static constexpr auto namespace_id = "default";
+    std::string bucket_name;
+    std::string scope_name;
+    std::string collection_name;
+    std::string index_name;
+    bool is_primary{ false };
+    bool ignore_if_does_not_exist{ 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]] query_index_drop_response make_response(error_context::http&& ctx, const encoded_response_type& encoded) const;
+};
+} // namespace couchbase::core::operations::management

package/deps/couchbase-transactions-cxx/deps/couchbase-cxx-client/core/operations/management/query_index_get_all.cxx

@@ -0,0 +1,125 @@
+/* -*- 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 "query_index_get_all.hxx"
+
+#include "core/utils/json.hxx"
+#include "error_utils.hxx"
+
+namespace couchbase::core::operations::management
+{
+std::error_code
+query_index_get_all_request::encode_to(encoded_request_type& encoded, couchbase::core::http_context& /* context */) const
+{
+    std::string bucket_cond = "bucket_id = $bucket_name";
+    std::string scope_cond = "(" + bucket_cond + " AND scope_id = $scope_name)";
+    std::string collection_cond = "(" + scope_cond + " AND keyspace_id = $collection_name)";
+
+    std::string where;
+    if (!collection_name.empty()) {
+        where = collection_cond;
+    } else if (!scope_name.empty()) {
+        where = scope_cond;
+    } else {
+        where = bucket_cond;
+    }
+
+    if (collection_name == "_default" || collection_name.empty()) {
+        std::string default_collection_cond = "(bucket_id IS MISSING AND keyspace_id = $bucket_name)";
+        where = "(" + where + " OR " + default_collection_cond + ")";
+    }
+
+    std::string statement = "SELECT `idx`.* FROM system:indexes AS idx"
+                            " WHERE " +
+                            where +
+                            " AND `using` = \"gsi\""
+                            " ORDER BY is_primary DESC, name ASC";
+
+    encoded.headers["content-type"] = "application/json";
+    tao::json::value body{ { "statement", statement },
+                           { "client_context_id", encoded.client_context_id },
+                           { "$bucket_name", bucket_name },
+                           { "$scope_name", scope_name },
+                           { "$collection_name", collection_name } };
+    encoded.method = "POST";
+    encoded.path = "/query/service";
+    encoded.body = utils::json::generate(body);
+    return {};
+}
+
+query_index_get_all_response
+query_index_get_all_request::make_response(couchbase::core::error_context::http&& ctx, const encoded_response_type& encoded) const
+{
+    query_index_get_all_response response{ std::move(ctx) };
+    if (!response.ctx.ec) {
+        if (encoded.status_code != 200) {
+            response.ctx.ec = extract_common_error_code(encoded.status_code, encoded.body.data());
+            return response;
+        }
+        tao::json::value payload{};
+        try {
+            payload = utils::json::parse(encoded.body.data());
+        } catch (const tao::pegtl::parse_error&) {
+            response.ctx.ec = errc::common::parsing_failure;
+            return response;
+        }
+        response.status = payload.at("status").get_string();
+        if (response.status != "success") {
+            return response;
+        }
+        for (const auto& entry : payload.at("results").get_array()) {
+            couchbase::core::management::query::index index;
+            index.type = entry.at("using").get_string();
+            index.name = entry.at("name").get_string();
+            index.state = entry.at("state").get_string();
+            if (const auto* prop = entry.find("is_primary")) {
+                index.is_primary = prop->get_boolean();
+            }
+            if (const auto* prop = entry.find("condition")) {
+                index.condition = prop->get_string();
+            }
+            if (const auto* prop = entry.find("partition")) {
+                index.partition = prop->get_string();
+            }
+            for (const auto& key : entry.at("index_key").get_array()) {
+                index.index_key.emplace_back(key.get_string());
+            }
+
+            std::string bucket_id, scope_id, keyspace_id;
+            if (const auto* prop = entry.find("bucket_id")) {
+                bucket_id = prop->get_string();
+            }
+            if (const auto* prop = entry.find("scope_id")) {
+                scope_id = prop->get_string();
+            }
+            if (const auto* prop = entry.find("keyspace_id")) {
+                keyspace_id = prop->get_string();
+            }
+            if (bucket_id.empty()) {
+                index.bucket_name = keyspace_id;
+            } else {
+                index.bucket_name = bucket_id;
+                index.scope_name = scope_id;
+                index.collection_name = keyspace_id;
+            }
+
+            response.indexes.emplace_back(index);
+        }
+    }
+    return response;
+}
+} // namespace couchbase::core::operations::management

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

@@ -0,0 +1,54 @@
+/* -*- 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/query_index.hxx"
+#include "core/platform/uuid.h"
+#include "core/timeout_defaults.hxx"
+
+namespace couchbase::core::operations::management
+{
+struct query_index_get_all_response {
+    error_context::http ctx;
+    std::string status{};
+    std::vector<couchbase::core::management::query::index> indexes{};
+};
+
+struct query_index_get_all_request {
+    using response_type = query_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::query;
+
+    std::string bucket_name;
+    std::string scope_name;
+    std::string collection_name;
+
+    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]] query_index_get_all_response make_response(error_context::http&& ctx, const encoded_response_type& encoded) const;
+};
+} // namespace couchbase::core::operations::management

package/deps/couchbase-transactions-cxx/deps/couchbase-cxx-client/core/operations/management/query_index_get_all_deferred.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 "query_index_get_all_deferred.hxx"
+
+#include "core/utils/json.hxx"
+#include "error_utils.hxx"
+
+namespace couchbase::core::operations::management
+{
+std::error_code
+query_index_get_all_deferred_request::encode_to(encoded_request_type& encoded, couchbase::core::http_context& /* context */) const
+{
+    std::string where;
+    if (collection_name.empty()) {
+        where = "(keyspace_id = $bucket_name AND bucket_id IS MISSING)";
+    } else {
+        where = "(bucket_id = $bucket_name AND scope_id = $scope_name AND keyspace_id = $collection_name)";
+    }
+
+    std::string statement = "SELECT RAW name FROM system:indexes"
+                            " WHERE " +
+                            where +
+                            " AND state = \"deferred\" AND `using` = \"gsi\""
+                            " ORDER BY is_primary DESC, name ASC";
+
+    encoded.headers["content-type"] = "application/json";
+    tao::json::value body{ { "statement", statement },
+                           { "client_context_id", encoded.client_context_id },
+                           { "$bucket_name", bucket_name },
+                           { "$scope_name", scope_name },
+                           { "$collection_name", collection_name } };
+    encoded.method = "POST";
+    encoded.path = "/query/service";
+    encoded.body = utils::json::generate(body);
+    return {};
+}
+
+query_index_get_all_deferred_response
+query_index_get_all_deferred_request::make_response(couchbase::core::error_context::http&& ctx, const encoded_response_type& encoded) const
+{
+    query_index_get_all_deferred_response response{ std::move(ctx) };
+    if (!response.ctx.ec) {
+        if (encoded.status_code != 200) {
+            response.ctx.ec = extract_common_error_code(encoded.status_code, encoded.body.data());
+            return response;
+        }
+        tao::json::value payload{};
+        try {
+            payload = utils::json::parse(encoded.body.data());
+        } catch (const tao::pegtl::parse_error&) {
+            response.ctx.ec = errc::common::parsing_failure;
+            return response;
+        }
+        response.status = payload.at("status").get_string();
+        if (response.status != "success") {
+            return response;
+        }
+        for (const auto& entry : payload.at("results").get_array()) {
+            response.index_names.emplace_back(entry.get_string());
+        }
+    }
+    return response;
+}
+} // namespace couchbase::core::operations::management