couchbase 4.1.2 → 4.1.3

package/deps/couchbase-transactions-cxx/deps/couchbase-cxx-client/core/operations/document_replace.cxx

@@ -0,0 +1,55 @@
+/* -*- 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 "document_replace.hxx"
+#include "core/utils/mutation_token.hxx"
+
+#include <couchbase/codec/codec_flags.hxx>
+#include <couchbase/error_codes.hxx>
+
+namespace couchbase::core::operations
+{
+std::error_code
+replace_request::encode_to(replace_request::encoded_request_type& encoded, mcbp_context&& /* context */) const
+{
+    encoded.opaque(opaque);
+    encoded.partition(partition);
+    encoded.cas(cas);
+    encoded.body().id(id);
+    encoded.body().expiry(expiry);
+    encoded.body().flags(flags);
+    encoded.body().content(value);
+    if (preserve_expiry) {
+        encoded.body().preserve_expiry();
+    }
+    if (codec::codec_flags::has_common_flags(flags, codec::codec_flags::common_flags::json)) {
+        encoded.datatype(protocol::datatype::json);
+    }
+    return {};
+}
+
+replace_response
+replace_request::make_response(key_value_error_context&& ctx, const encoded_response_type& encoded) const
+{
+    replace_response response{ std::move(ctx) };
+    if (!response.ctx.ec()) {
+        response.cas = encoded.cas();
+        response.token = couchbase::utils::build_mutation_token(encoded.body().token(), partition, response.ctx.bucket());
+    }
+    return response;
+}
+} // namespace couchbase::core::operations

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

@@ -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.
+ */
+
+#pragma once
+
+#include "core/error_context/key_value.hxx"
+#include "core/impl/with_legacy_durability.hxx"
+#include "core/io/mcbp_context.hxx"
+#include "core/io/mcbp_traits.hxx"
+#include "core/io/retry_context.hxx"
+#include "core/operations/operation_traits.hxx"
+#include "core/protocol/client_request.hxx"
+#include "core/protocol/cmd_replace.hxx"
+#include "core/timeout_defaults.hxx"
+#include "core/tracing/request_tracer.hxx"
+
+#include <couchbase/durability_level.hxx>
+
+namespace couchbase::core::operations
+{
+
+struct replace_response {
+    key_value_error_context ctx;
+    couchbase::cas cas{};
+    mutation_token token{};
+};
+
+struct replace_request {
+    using response_type = replace_response;
+    using encoded_request_type = protocol::client_request<protocol::replace_request_body>;
+    using encoded_response_type = protocol::client_response<protocol::replace_response_body>;
+
+    document_id id;
+    std::vector<std::byte> value;
+    std::uint16_t partition{};
+    std::uint32_t opaque{};
+    std::uint32_t flags{ 0 };
+    std::uint32_t expiry{ 0 };
+    couchbase::cas cas{ 0 };
+    couchbase::durability_level durability_level{ durability_level::none };
+    std::optional<std::chrono::milliseconds> timeout{};
+    io::retry_context<io::retry_strategy::best_effort> retries{ false };
+    bool preserve_expiry{ false };
+    std::shared_ptr<tracing::request_span> parent_span{ nullptr };
+
+    [[nodiscard]] std::error_code encode_to(encoded_request_type& encoded, mcbp_context&& context) const;
+
+    [[nodiscard]] replace_response make_response(key_value_error_context&& ctx, const encoded_response_type& encoded) const;
+};
+
+using replace_request_with_legacy_durability = impl::with_legacy_durability<replace_request>;
+
+template<>
+struct is_compound_operation<replace_request_with_legacy_durability> : public std::true_type {
+};
+
+} // namespace couchbase::core::operations
+
+namespace couchbase::core::io::mcbp_traits
+{
+template<>
+struct supports_durability<couchbase::core::operations::replace_request> : public std::true_type {
+};
+
+template<>
+struct supports_parent_span<couchbase::core::operations::replace_request> : public std::true_type {
+};
+} // namespace couchbase::core::io::mcbp_traits

package/deps/couchbase-transactions-cxx/deps/couchbase-cxx-client/core/operations/document_search.cxx

@@ -0,0 +1,312 @@
+/* -*- 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 "document_search.hxx"
+
+#include "core/logger/logger.hxx"
+#include "core/utils/json.hxx"
+
+#include <couchbase/error_codes.hxx>
+
+#include <tao/json/contrib/traits.hpp>
+
+namespace couchbase::core::operations
+{
+std::error_code
+search_request::encode_to(search_request::encoded_request_type& encoded, http_context& context)
+{
+    auto body = tao::json::value{
+        { "query", utils::json::parse(query) },
+        { "explain", explain },
+        { "ctl", { { "timeout", encoded.timeout.count() } } },
+    };
+    if (limit) {
+        body["size"] = *limit;
+    }
+    if (skip) {
+        body["from"] = *skip;
+    }
+    if (disable_scoring) {
+        body["score"] = "none";
+    }
+    if (include_locations) {
+        body["includeLocations"] = true;
+    }
+    if (highlight_style || !highlight_fields.empty()) {
+        tao::json::value highlight;
+        if (highlight_style) {
+            switch (*highlight_style) {
+                case couchbase::core::search_highlight_style::html:
+                    highlight["style"] = "html";
+                    break;
+                case couchbase::core::search_highlight_style::ansi:
+                    highlight["style"] = "ansi";
+                    break;
+            }
+        }
+        if (!highlight_fields.empty()) {
+            highlight["fields"] = highlight_fields;
+        }
+        body["highlight"] = highlight;
+    }
+    if (!fields.empty()) {
+        body["fields"] = fields;
+    }
+    if (!sort_specs.empty()) {
+        body["sort"] = tao::json::empty_array;
+        for (const auto& spec : sort_specs) {
+            body["sort"].get_array().push_back(utils::json::parse(spec));
+        }
+    }
+    if (!facets.empty()) {
+        body["facets"] = tao::json::empty_object;
+        for (const auto& [name, facet] : facets) {
+            body["facets"][name] = utils::json::parse(facet);
+        }
+    }
+    if (!mutation_state.empty()) {
+        tao::json::value scan_vectors = tao::json::empty_object;
+        for (const auto& token : mutation_state) {
+            auto key = fmt::format("{}/{}", token.partition_id(), token.partition_uuid());
+            const auto* old_val = scan_vectors.find(key);
+            if (old_val == nullptr || (old_val->is_integer() && old_val->get_unsigned() < token.sequence_number())) {
+                scan_vectors[key] = token.sequence_number();
+            }
+        }
+        body["ctl"]["consistency"] = tao::json::value{
+            { "level", "at_plus" },
+            { "vectors", { { index_name, scan_vectors } } },
+        };
+    }
+    if (scope_name) {
+        body["scope"] = scope_name.value();
+        body["collections"] = collections;
+    }
+
+    encoded.type = type;
+    encoded.headers["content-type"] = "application/json";
+    encoded.method = "POST";
+    encoded.path = fmt::format("/api/index/{}/query", index_name);
+    body_str = utils::json::generate(body);
+    encoded.body = body_str;
+    if (context.options.show_queries) {
+        LOG_INFO("SEARCH: {}", utils::json::generate(body["query"]));
+    } else {
+        LOG_DEBUG("SEARCH: {}", utils::json::generate(body["query"]));
+    }
+    if (row_callback) {
+        encoded.streaming.emplace(couchbase::core::io::streaming_settings{
+          "/hits/^",
+          4,
+          std::move(row_callback.value()),
+        });
+    }
+    return {};
+}
+
+search_response
+search_request::make_response(error_context::search&& ctx, const encoded_response_type& encoded) const
+{
+    search_response response{ std::move(ctx) };
+    response.meta.client_context_id = response.ctx.client_context_id;
+    response.ctx.index_name = index_name;
+    response.ctx.query = query.str();
+    response.ctx.parameters = body_str;
+    if (!response.ctx.ec) {
+        if (encoded.status_code == 200) {
+            tao::json::value payload{};
+            try {
+                payload = utils::json::parse(encoded.body.data());
+            } catch (const tao::pegtl::parse_error&) {
+                response.ctx.ec = errc::common::parsing_failure;
+                return response;
+            }
+            response.meta.metrics.took = std::chrono::nanoseconds(payload.at("took").get_unsigned());
+            response.meta.metrics.max_score = payload.at("max_score").as<double>();
+            response.meta.metrics.total_rows = payload.at("total_hits").get_unsigned();
+
+            if (auto& status_prop = payload.at("status"); status_prop.is_string()) {
+                response.status = status_prop.get_string();
+                if (response.status == "ok") {
+                    return response;
+                }
+            } else if (status_prop.is_object()) {
+                response.meta.metrics.error_partition_count = status_prop.at("failed").get_unsigned();
+                response.meta.metrics.success_partition_count = status_prop.at("successful").get_unsigned();
+                if (const auto* errors = status_prop.find("errors"); errors != nullptr && errors->is_object()) {
+                    for (const auto& [location, message] : errors->get_object()) {
+                        response.meta.errors.try_emplace(location, message.get_string());
+                    }
+                }
+            } else {
+                response.ctx.ec = errc::common::internal_server_failure;
+                return response;
+            }
+
+            if (const auto* rows = payload.find("hits"); rows != nullptr && rows->is_array()) {
+                for (const auto& entry : rows->get_array()) {
+                    search_response::search_row row{};
+                    row.index = entry.at("index").get_string();
+                    row.id = entry.at("id").get_string();
+                    row.score = entry.at("score").as<double>();
+                    if (const auto* locations_map = entry.find("locations"); locations_map != nullptr && locations_map->is_object()) {
+                        for (const auto& [field, terms] : locations_map->get_object()) {
+                            for (const auto& [term, locations] : terms.get_object()) {
+                                for (const auto& loc : locations.get_array()) {
+                                    search_response::search_location location{};
+                                    location.field = field;
+                                    location.term = term;
+                                    location.position = loc.at("pos").get_unsigned();
+                                    location.start_offset = loc.at("start").get_unsigned();
+                                    location.end_offset = loc.at("end").get_unsigned();
+                                    if (const auto* array_positions = loc.find("array_positions");
+                                        array_positions != nullptr && array_positions->is_array()) {
+                                        location.array_positions.emplace(array_positions->as<std::vector<std::uint64_t>>());
+                                    }
+                                    row.locations.emplace_back(location);
+                                }
+                            }
+                        }
+                    }
+
+                    if (const auto* fragments_map = entry.find("fragments"); fragments_map != nullptr && fragments_map->is_object()) {
+                        for (const auto& [field, fragments] : fragments_map->get_object()) {
+                            row.fragments.try_emplace(field, fragments.as<std::vector<std::string>>());
+                        }
+                    }
+                    if (const auto* response_fields = entry.find("fields"); response_fields != nullptr && response_fields->is_object()) {
+                        row.fields = utils::json::generate(*response_fields);
+                    }
+                    if (const auto* explanation = entry.find("explanation"); explanation != nullptr && explanation->is_object()) {
+                        row.explanation = utils::json::generate(*explanation);
+                    }
+                    response.rows.emplace_back(row);
+                }
+            }
+
+            if (const auto* response_facets = payload.find("facets"); response_facets != nullptr && response_facets->is_object()) {
+                for (const auto& [name, object] : response_facets->get_object()) {
+                    search_response::search_facet facet;
+                    facet.name = name;
+                    facet.field = object.at("field").get_string();
+                    facet.total = object.at("total").get_unsigned();
+                    facet.missing = object.at("missing").get_unsigned();
+                    facet.other = object.at("other").get_unsigned();
+
+                    if (const auto* date_ranges = object.find("date_ranges"); date_ranges != nullptr && date_ranges->is_array()) {
+                        for (const auto& date_range : date_ranges->get_array()) {
+                            search_response::search_facet::date_range_facet date_range_facet;
+                            date_range_facet.name = date_range.at("name").get_string();
+                            date_range_facet.count = date_range.at("count").get_unsigned();
+                            if (const auto* start = date_range.find("start"); start != nullptr && start->is_string()) {
+                                date_range_facet.start = start->get_string();
+                            }
+                            if (const auto* end = date_range.find("end"); end != nullptr && end->is_string()) {
+                                date_range_facet.end = end->get_string();
+                            }
+                            facet.date_ranges.emplace_back(date_range_facet);
+                        }
+                    }
+
+                    if (const auto& numeric_ranges = object.find("numeric_ranges");
+                        numeric_ranges != nullptr && numeric_ranges->is_array()) {
+                        for (const auto& numeric_range : numeric_ranges->get_array()) {
+                            search_response::search_facet::numeric_range_facet numeric_range_facet;
+                            numeric_range_facet.name = numeric_range.at("name").get_string();
+                            numeric_range_facet.count = numeric_range.at("count").get_unsigned();
+                            if (const auto* min = numeric_range.find("min"); min != nullptr) {
+                                if (min->is_double()) {
+                                    numeric_range_facet.min = min->as<double>();
+                                } else if (min->is_integer()) {
+                                    numeric_range_facet.min = min->get_unsigned();
+                                }
+                            }
+                            if (const auto* max = numeric_range.find("max"); max != nullptr) {
+                                if (max->is_double()) {
+                                    numeric_range_facet.max = max->as<double>();
+                                } else if (max->is_integer()) {
+                                    numeric_range_facet.max = max->get_unsigned();
+                                }
+                            }
+                            facet.numeric_ranges.emplace_back(numeric_range_facet);
+                        }
+                    }
+
+                    if (const auto* terms = object.find("terms"); terms != nullptr && terms->is_array()) {
+                        for (const auto& term : terms->get_array()) {
+                            search_response::search_facet::term_facet term_facet;
+                            term_facet.term = term.at("term").get_string();
+                            term_facet.count = term.at("count").get_unsigned();
+                            facet.terms.emplace_back(term_facet);
+                        }
+                    }
+
+                    response.facets.emplace_back(facet);
+                }
+            }
+            return response;
+        }
+        if (encoded.status_code == 400) {
+            tao::json::value payload{};
+            try {
+                payload = utils::json::parse(encoded.body.data());
+            } catch (const tao::pegtl::parse_error&) {
+                response.ctx.ec = errc::common::parsing_failure;
+                return response;
+            }
+            response.status = payload.at("status").get_string();
+            response.error = payload.at("error").get_string();
+            if (response.error.find("index not found") != std::string::npos) {
+                response.ctx.ec = errc::common::index_not_found;
+                return response;
+            }
+            if (response.error.find("no planPIndexes for indexName") != std::string::npos) {
+                response.ctx.ec = errc::search::index_not_ready;
+                return response;
+            }
+            if (response.error.find("pindex_consistency mismatched partition") != std::string::npos) {
+                response.ctx.ec = errc::search::consistency_mismatch;
+                return response;
+            }
+            if (response.error.find("num_fts_indexes (active + pending)") != std::string::npos) {
+                response.ctx.ec = errc::common::quota_limited;
+                return response;
+            }
+        } else if (encoded.status_code == 429) {
+            tao::json::value payload{};
+            try {
+                payload = utils::json::parse(encoded.body.data());
+            } catch (const tao::pegtl::parse_error&) {
+                response.ctx.ec = errc::common::parsing_failure;
+                return response;
+            }
+            response.status = payload.at("status").get_string();
+            response.error = payload.at("error").get_string();
+
+            if (response.error.find("num_concurrent_requests") != std::string::npos ||
+                response.error.find("num_queries_per_min") != std::string::npos ||
+                response.error.find("ingress_mib_per_min") != std::string::npos ||
+                response.error.find("egress_mib_per_min") != std::string::npos) {
+                response.ctx.ec = errc::common::rate_limited;
+                return response;
+            }
+        }
+        response.ctx.ec = errc::common::internal_server_failure;
+    }
+    return response;
+}
+} // namespace couchbase::core::operations

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

@@ -0,0 +1,163 @@
+/* -*- 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/search.hxx"
+#include "core/io/http_context.hxx"
+#include "core/io/http_message.hxx"
+#include "core/io/http_traits.hxx"
+#include "core/json_string.hxx"
+#include "core/platform/uuid.h"
+#include "core/search_highlight_style.hxx"
+#include "core/search_scan_consistency.hxx"
+#include "core/timeout_defaults.hxx"
+
+#include <couchbase/mutation_token.hxx>
+
+#include <map>
+#include <variant>
+#include <vector>
+
+namespace couchbase::core::operations
+{
+struct search_response {
+    struct search_metrics {
+        std::chrono::nanoseconds took{};
+        std::uint64_t total_rows{};
+        double max_score{};
+        std::uint64_t success_partition_count{};
+        std::uint64_t error_partition_count{};
+    };
+
+    struct search_meta_data {
+        std::string client_context_id;
+        search_metrics metrics{};
+        std::map<std::string, std::string> errors;
+    };
+
+    struct search_location {
+        std::string field;
+        std::string term;
+        std::uint64_t position;
+        std::uint64_t start_offset;
+        std::uint64_t end_offset;
+        std::optional<std::vector<std::uint64_t>> array_positions{};
+    };
+
+    struct search_row {
+        std::string index;
+        std::string id;
+        double score;
+        std::vector<search_location> locations{};
+        std::map<std::string, std::vector<std::string>> fragments{};
+        std::string fields{};
+        std::string explanation{};
+    };
+
+    struct search_facet {
+        struct term_facet {
+            std::string term{};
+            std::uint64_t count{};
+        };
+
+        struct date_range_facet {
+            std::string name{};
+            std::uint64_t count{};
+            std::optional<std::string> start{};
+            std::optional<std::string> end{};
+        };
+
+        struct numeric_range_facet {
+            std::string name{};
+            std::uint64_t count{};
+            std::variant<std::monostate, std::uint64_t, double> min{};
+            std::variant<std::monostate, std::uint64_t, double> max{};
+        };
+
+        std::string name;
+        std::string field;
+        std::uint64_t total;
+        std::uint64_t missing;
+        std::uint64_t other;
+        std::vector<term_facet> terms{};
+        std::vector<date_range_facet> date_ranges{};
+        std::vector<numeric_range_facet> numeric_ranges{};
+    };
+
+    error_context::search ctx;
+    std::string status{};
+    search_meta_data meta{};
+    std::string error{};
+    std::vector<search_row> rows{};
+    std::vector<search_facet> facets{};
+};
+
+struct search_request {
+    using response_type = search_response;
+    using encoded_request_type = io::http_request;
+    using encoded_response_type = io::http_response;
+    using error_context_type = error_context::search;
+
+    static const inline service_type type = service_type::search;
+
+    std::string index_name;
+    couchbase::core::json_string query;
+
+    std::optional<std::uint32_t> limit{};
+    std::optional<std::uint32_t> skip{};
+    bool explain{ false };
+    bool disable_scoring{ false };
+    /**
+     * UNCOMMITTED: If set to true, will include the vector of search_location in rows.
+     */
+    bool include_locations{ false };
+
+    std::optional<couchbase::core::search_highlight_style> highlight_style{};
+    std::vector<std::string> highlight_fields{};
+    std::vector<std::string> fields{};
+    std::optional<std::string> scope_name{};
+    std::vector<std::string> collections{};
+
+    std::optional<couchbase::core::search_scan_consistency> scan_consistency{};
+    std::vector<mutation_token> mutation_state{};
+
+    std::vector<std::string> sort_specs{};
+
+    std::map<std::string, std::string> facets{};
+
+    std::map<std::string, couchbase::core::json_string> raw{};
+    std::optional<std::function<utils::json::stream_control(std::string)>> row_callback{};
+    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);
+
+    [[nodiscard]] search_response make_response(error_context::search&& ctx, const encoded_response_type& encoded) const;
+
+    std::string body_str{};
+
+    std::shared_ptr<tracing::request_span> parent_span{ nullptr };
+};
+
+} // namespace couchbase::core::operations
+namespace couchbase::core::io::http_traits
+{
+template<>
+struct supports_parent_span<couchbase::core::operations::search_request> : public std::true_type {
+};
+} // namespace couchbase::core::io::http_traits

package/deps/couchbase-transactions-cxx/deps/couchbase-cxx-client/core/operations/document_touch.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 "document_touch.hxx"
+
+#include <couchbase/error_codes.hxx>
+
+namespace couchbase::core::operations
+{
+std::error_code
+touch_request::encode_to(touch_request::encoded_request_type& encoded, mcbp_context&& /* context */) const
+{
+    encoded.opaque(opaque);
+    encoded.partition(partition);
+    encoded.body().id(id);
+    encoded.body().expiry(expiry);
+    return {};
+}
+
+touch_response
+touch_request::make_response(key_value_error_context&& ctx, const encoded_response_type& encoded) const
+{
+    touch_response response{ std::move(ctx) };
+    if (!response.ctx.ec()) {
+        response.cas = encoded.cas();
+    }
+    return response;
+}
+} // namespace couchbase::core::operations