couchbase 4.1.1 → 4.1.3

package/deps/couchbase-transactions-cxx/deps/couchbase-cxx-client/couchbase/operations/document_get_and_touch.hxx

@@ -1,54 +0,0 @@
-/* -*- 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 <couchbase/error_context/key_value.hxx>
-#include <couchbase/io/mcbp_context.hxx>
-#include <couchbase/io/retry_context.hxx>
-#include <couchbase/protocol/client_request.hxx>
-#include <couchbase/protocol/cmd_get_and_touch.hxx>
-#include <couchbase/timeout_defaults.hxx>
-
-namespace couchbase::operations
-{
-
-struct get_and_touch_response {
-    error_context::key_value ctx;
-    std::string value{};
-    couchbase::cas cas{};
-    std::uint32_t flags{};
-};
-
-struct get_and_touch_request {
-    using response_type = get_and_touch_response;
-    using encoded_request_type = protocol::client_request<protocol::get_and_touch_request_body>;
-    using encoded_response_type = protocol::client_response<protocol::get_and_touch_response_body>;
-
-    document_id id;
-    uint16_t partition{};
-    uint32_t opaque{};
-    uint32_t expiry{};
-    std::optional<std::chrono::milliseconds> timeout{};
-    io::retry_context<io::retry_strategy::best_effort> retries{ false };
-
-    [[nodiscard]] std::error_code encode_to(encoded_request_type& encoded, mcbp_context&& context) const;
-
-    [[nodiscard]] get_and_touch_response make_response(error_context::key_value&& ctx, const encoded_response_type& encoded) const;
-};
-
-} // namespace couchbase::operations

package/deps/couchbase-transactions-cxx/deps/couchbase-cxx-client/couchbase/operations/document_get_projected.cxx

@@ -1,227 +0,0 @@
-/* -*- 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 <couchbase/operations/document_get_projected.hxx>
-
-#include <couchbase/errors.hxx>
-#include <couchbase/utils/json.hxx>
-
-namespace couchbase::operations
-{
-
-static std::optional<tao::json::value>
-subdoc_lookup(tao::json::value& root, const std::string& path)
-{
-    std::string::size_type offset = 0;
-    tao::json::value* cur = &root;
-
-    while (offset < path.size()) {
-        std::string::size_type idx = path.find_first_of(".[]", offset);
-
-        if (idx == std::string::npos) {
-            std::string key = path.substr(offset);
-            if (auto* val = cur->find(key); val != nullptr) {
-                return *val;
-            }
-            break;
-        }
-
-        if (path[idx] == '.' || path[idx] == '[') {
-            std::string key = path.substr(offset, idx - offset);
-            auto* val = cur->find(key);
-            if (val == nullptr) {
-                break;
-            }
-            cur = val;
-        } else if (path[idx] == ']') {
-            if (!cur->is_array()) {
-                break;
-            }
-            std::string key = path.substr(offset, idx - offset);
-            if (int array_index = std::stoi(key); array_index == -1) {
-                cur = &cur->get_array().back();
-            } else if (static_cast<std::size_t>(array_index) < cur->get_array().size()) {
-                cur = &cur->get_array().back();
-            } else {
-                break;
-            }
-            if (idx < path.size() - 1) {
-                return *cur;
-            }
-            idx += 1;
-        }
-        offset = idx + 1;
-    }
-
-    return {};
-}
-
-static void
-subdoc_apply_projection(tao::json::value& root, const std::string& path, tao::json::value& value, bool preserve_array_indexes)
-{
-    std::string::size_type offset = 0;
-    tao::json::value* cur = &root;
-
-    while (offset < path.size()) {
-        std::string::size_type idx = path.find_first_of(".[]", offset);
-
-        if (idx == std::string::npos) {
-            cur->operator[](path.substr(offset)) = value;
-            break;
-        }
-
-        if (path[idx] == '.') {
-            std::string key = path.substr(offset, idx - offset);
-            tao::json::value* child = cur->find(key);
-            if (child == nullptr) {
-                cur->operator[](key) = tao::json::empty_object;
-                child = cur->find(key);
-            }
-            cur = child;
-        } else if (path[idx] == '[') {
-            std::string key = path.substr(offset, idx - offset);
-            tao::json::value* child = cur->find(key);
-            if (child == nullptr) {
-                cur->operator[](key) = tao::json::empty_array;
-                child = cur->find(key);
-            }
-            cur = child;
-        } else if (path[idx] == ']') {
-            tao::json::value child;
-            if (idx == path.size() - 1) {
-                child = value;
-            } else if (path[idx + 1] == '.') {
-                child = tao::json::empty_object;
-            } else if (path[idx + 1] == '[') {
-                child = tao::json::empty_array;
-            } else {
-                Expects(false);
-            }
-            if (preserve_array_indexes) {
-                int array_index = std::stoi(path.substr(offset, idx - offset));
-                if (array_index >= 0) {
-                    if (static_cast<std::size_t>(array_index) >= cur->get_array().size()) {
-                        cur->get_array().resize(static_cast<std::size_t>(array_index + 1), tao::json::null);
-                    }
-                    cur->at(static_cast<std::size_t>(array_index)) = child;
-                    cur = &cur->at(static_cast<std::size_t>(array_index));
-                } else {
-                    // index is negative, just append and let user decide what it means
-                    cur->get_array().push_back(child);
-                    cur = &cur->get_array().back();
-                }
-            } else {
-                cur->get_array().push_back(child);
-                cur = &cur->get_array().back();
-            }
-            ++idx;
-        }
-        offset = idx + 1;
-    }
-}
-
-std::error_code
-get_projected_request::encode_to(get_projected_request::encoded_request_type& encoded, mcbp_context&& /* context */)
-{
-    encoded.opaque(opaque);
-    encoded.partition(partition);
-    encoded.body().id(id);
-
-    effective_projections = projections;
-    std::size_t num_projections = effective_projections.size();
-    if (with_expiry) {
-        num_projections++;
-    }
-    if (num_projections > 16) {
-        // too many subdoc operations, better fetch full document
-        effective_projections.clear();
-    }
-
-    protocol::lookup_in_request_body::lookup_in_specs specs{};
-    if (with_expiry) {
-        specs.add_spec(protocol::subdoc_opcode::get, true, "$document.exptime");
-    }
-    if (effective_projections.empty()) {
-        specs.add_spec(protocol::subdoc_opcode::get_doc, false, "");
-    } else {
-        for (const auto& path : effective_projections) {
-            specs.add_spec(protocol::subdoc_opcode::get, false, path);
-        }
-    }
-    encoded.body().specs(specs);
-    return {};
-}
-
-get_projected_response
-get_projected_request::make_response(error_context::key_value&& ctx, const encoded_response_type& encoded) const
-{
-    get_projected_response response{ std::move(ctx) };
-    if (!response.ctx.ec) {
-        response.cas = encoded.cas();
-        if (with_expiry && !encoded.body().fields()[0].value.empty()) {
-            response.expiry = gsl::narrow_cast<std::uint32_t>(std::stoul(encoded.body().fields()[0].value));
-        }
-        if (effective_projections.empty()) {
-            // from full document
-            if (projections.empty() && with_expiry) {
-                // special case when user only wanted full+expiration
-                response.value = encoded.body().fields()[1].value;
-            } else {
-                tao::json::value full_doc{};
-                try {
-                    full_doc = utils::json::parse(encoded.body().fields()[with_expiry ? 1 : 0].value);
-                } catch (const tao::pegtl::parse_error&) {
-                    response.ctx.ec = error::common_errc::parsing_failure;
-                    return response;
-                }
-                tao::json::value new_doc;
-                for (const auto& projection : projections) {
-                    auto value_to_apply = subdoc_lookup(full_doc, projection);
-                    if (value_to_apply) {
-                        subdoc_apply_projection(new_doc, projection, *value_to_apply, preserve_array_indexes);
-                    } else {
-                        response.ctx.ec = error::key_value_errc::path_not_found;
-                        return response;
-                    }
-                }
-                response.value = utils::json::generate(new_doc);
-            }
-        } else {
-            tao::json::value new_doc = tao::json::empty_object;
-            std::size_t offset = with_expiry ? 1 : 0;
-            for (const auto& projection : projections) {
-                const auto& field = encoded.body().fields()[offset++];
-                if (field.status == protocol::status::success && !field.value.empty()) {
-                    tao::json::value value_to_apply{};
-                    try {
-                        value_to_apply = utils::json::parse(field.value);
-                    } catch (const tao::pegtl::parse_error&) {
-                        response.ctx.ec = error::common_errc::parsing_failure;
-                        return response;
-                    }
-                    subdoc_apply_projection(new_doc, projection, value_to_apply, preserve_array_indexes);
-                } else {
-                    response.ctx.ec = error::key_value_errc::path_not_found;
-                    return response;
-                }
-            }
-            response.value = utils::json::generate(new_doc);
-        }
-    }
-    return response;
-}
-} // namespace couchbase::operations

package/deps/couchbase-transactions-cxx/deps/couchbase-cxx-client/couchbase/operations/document_get_projected.hxx

@@ -1,58 +0,0 @@
-/* -*- 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 <couchbase/error_context/key_value.hxx>
-#include <couchbase/io/mcbp_context.hxx>
-#include <couchbase/io/retry_context.hxx>
-#include <couchbase/protocol/client_request.hxx>
-#include <couchbase/protocol/cmd_lookup_in.hxx>
-#include <couchbase/timeout_defaults.hxx>
-
-namespace couchbase::operations
-{
-
-struct get_projected_response {
-    error_context::key_value ctx;
-    std::string value{};
-    couchbase::cas cas{};
-    std::uint32_t flags{};
-    std::optional<std::uint32_t> expiry{};
-};
-
-struct get_projected_request {
-    using response_type = get_projected_response;
-    using encoded_request_type = protocol::client_request<protocol::lookup_in_request_body>;
-    using encoded_response_type = protocol::client_response<protocol::lookup_in_response_body>;
-
-    document_id id;
-    std::uint16_t partition{};
-    std::uint32_t opaque{};
-    std::vector<std::string> projections{};
-    bool with_expiry{ false };
-    std::vector<std::string> effective_projections{};
-    bool preserve_array_indexes{ false };
-    std::optional<std::chrono::milliseconds> timeout{};
-    io::retry_context<io::retry_strategy::best_effort> retries{ true };
-
-    [[nodiscard]] std::error_code encode_to(encoded_request_type& encoded, mcbp_context&& context);
-
-    [[nodiscard]] get_projected_response make_response(error_context::key_value&& ctx, const encoded_response_type& encoded) const;
-};
-
-} // namespace couchbase::operations

package/deps/couchbase-transactions-cxx/deps/couchbase-cxx-client/couchbase/operations/document_increment.cxx

@@ -1,57 +0,0 @@
-/* -*- 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 <couchbase/operations/document_increment.hxx>
-
-#include <couchbase/errors.hxx>
-
-namespace couchbase::operations
-{
-std::error_code
-increment_request::encode_to(increment_request::encoded_request_type& encoded, mcbp_context&& /* context */) const
-{
-    encoded.opaque(opaque);
-    encoded.partition(partition);
-    encoded.body().id(id);
-    encoded.body().delta(delta);
-    if (initial_value) {
-        encoded.body().initial_value(initial_value.value());
-        encoded.body().expiry(expiry);
-    } else {
-        encoded.body().initial_value(0);
-        encoded.body().expiry(0xffff'ffff);
-    }
-    if (preserve_expiry) {
-        encoded.body().preserve_expiry();
-    }
-    return {};
-}
-
-increment_response
-increment_request::make_response(error_context::key_value&& ctx, const encoded_response_type& encoded) const
-{
-    increment_response response{ std::move(ctx) };
-    if (!response.ctx.ec) {
-        response.cas = encoded.cas();
-        response.content = encoded.body().content();
-        response.token = encoded.body().token();
-        response.token.partition_id = partition;
-        response.token.bucket_name = response.ctx.id.bucket();
-    }
-    return response;
-}
-} // namespace couchbase::operations

package/deps/couchbase-transactions-cxx/deps/couchbase-cxx-client/couchbase/operations/document_increment.hxx

@@ -1,67 +0,0 @@
-/* -*- 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 <couchbase/error_context/key_value.hxx>
-#include <couchbase/io/mcbp_context.hxx>
-#include <couchbase/io/mcbp_traits.hxx>
-#include <couchbase/io/retry_context.hxx>
-#include <couchbase/protocol/client_request.hxx>
-#include <couchbase/protocol/cmd_increment.hxx>
-#include <couchbase/protocol/durability_level.hxx>
-#include <couchbase/timeout_defaults.hxx>
-
-namespace couchbase::operations
-{
-
-struct increment_response {
-    error_context::key_value ctx;
-    std::uint64_t content{};
-    couchbase::cas cas{};
-    mutation_token token{};
-};
-
-struct increment_request {
-    using response_type = increment_response;
-    using encoded_request_type = protocol::client_request<protocol::increment_request_body>;
-    using encoded_response_type = protocol::client_response<protocol::increment_response_body>;
-
-    document_id id;
-    std::uint16_t partition{};
-    std::uint32_t opaque{};
-    std::uint32_t expiry{ 0 };
-    std::uint64_t delta{ 1 };
-    std::optional<std::uint64_t> initial_value{};
-    protocol::durability_level durability_level{ protocol::durability_level::none };
-    std::optional<std::chrono::milliseconds> timeout{};
-    io::retry_context<io::retry_strategy::best_effort> retries{ false };
-    bool preserve_expiry{ false };
-
-    [[nodiscard]] std::error_code encode_to(encoded_request_type& encoded, mcbp_context&& context) const;
-
-    [[nodiscard]] increment_response make_response(error_context::key_value&& ctx, const encoded_response_type& encoded) const;
-};
-
-} // namespace couchbase::operations
-
-namespace couchbase::io::mcbp_traits
-{
-template<>
-struct supports_durability<couchbase::operations::increment_request> : public std::true_type {
-};
-} // namespace couchbase::io::mcbp_traits

package/deps/couchbase-transactions-cxx/deps/couchbase-cxx-client/couchbase/operations/document_insert.cxx

@@ -1,48 +0,0 @@
-/* -*- 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 <couchbase/operations/document_insert.hxx>
-
-#include <couchbase/errors.hxx>
-
-namespace couchbase::operations
-{
-std::error_code
-insert_request::encode_to(insert_request::encoded_request_type& encoded, mcbp_context&& /* context */) const
-{
-    encoded.opaque(opaque);
-    encoded.partition(partition);
-    encoded.body().id(id);
-    encoded.body().expiry(expiry);
-    encoded.body().flags(flags);
-    encoded.body().content(value);
-    return {};
-}
-
-insert_response
-insert_request::make_response(error_context::key_value&& ctx, const encoded_response_type& encoded) const
-{
-    insert_response response{ std::move(ctx) };
-    if (!response.ctx.ec) {
-        response.cas = encoded.cas();
-        response.token = encoded.body().token();
-        response.token.partition_id = partition;
-        response.token.bucket_name = response.ctx.id.bucket();
-    }
-    return response;
-}
-} // namespace couchbase::operations

package/deps/couchbase-transactions-cxx/deps/couchbase-cxx-client/couchbase/operations/document_insert.hxx

@@ -1,65 +0,0 @@
-/* -*- 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 <couchbase/error_context/key_value.hxx>
-#include <couchbase/io/mcbp_context.hxx>
-#include <couchbase/io/mcbp_traits.hxx>
-#include <couchbase/io/retry_context.hxx>
-#include <couchbase/protocol/client_request.hxx>
-#include <couchbase/protocol/cmd_insert.hxx>
-#include <couchbase/protocol/durability_level.hxx>
-#include <couchbase/timeout_defaults.hxx>
-
-namespace couchbase::operations
-{
-
-struct insert_response {
-    error_context::key_value ctx;
-    couchbase::cas cas{};
-    mutation_token token{};
-};
-
-struct insert_request {
-    using response_type = insert_response;
-    using encoded_request_type = protocol::client_request<protocol::insert_request_body>;
-    using encoded_response_type = protocol::client_response<protocol::insert_response_body>;
-
-    document_id id;
-    std::string value;
-    uint16_t partition{};
-    uint32_t opaque{};
-    uint32_t flags{ 0 };
-    uint32_t expiry{ 0 };
-    protocol::durability_level durability_level{ protocol::durability_level::none };
-    std::optional<std::chrono::milliseconds> timeout{};
-    io::retry_context<io::retry_strategy::best_effort> retries{ false };
-
-    [[nodiscard]] std::error_code encode_to(encoded_request_type& encoded, mcbp_context&& context) const;
-
-    [[nodiscard]] insert_response make_response(error_context::key_value&& ctx, const encoded_response_type& encoded) const;
-};
-
-} // namespace couchbase::operations
-
-namespace couchbase::io::mcbp_traits
-{
-template<>
-struct supports_durability<couchbase::operations::insert_request> : public std::true_type {
-};
-} // namespace couchbase::io::mcbp_traits

package/deps/couchbase-transactions-cxx/deps/couchbase-cxx-client/couchbase/operations/document_lookup_in.cxx

@@ -1,81 +0,0 @@
-/* -*- 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 <couchbase/errors.hxx>
-#include <couchbase/operations/document_lookup_in.hxx>
-#include <couchbase/utils/json.hxx>
-
-namespace couchbase::operations
-{
-std::error_code
-lookup_in_request::encode_to(lookup_in_request::encoded_request_type& encoded, mcbp_context&& /* context */)
-{
-    for (std::size_t i = 0; i < specs.entries.size(); ++i) {
-        specs.entries[i].original_index = i;
-    }
-    std::stable_sort(specs.entries.begin(), specs.entries.end(), [](const auto& lhs, const auto& rhs) {
-        return (lhs.flags & protocol::lookup_in_request_body::lookup_in_specs::path_flag_xattr) >
-               (rhs.flags & protocol::lookup_in_request_body::lookup_in_specs::path_flag_xattr);
-    });
-
-    encoded.opaque(opaque);
-    encoded.partition(partition);
-    encoded.body().id(id);
-    encoded.body().access_deleted(access_deleted);
-    encoded.body().specs(specs);
-    return {};
-}
-
-lookup_in_response
-lookup_in_request::make_response(error_context::key_value&& ctx, const encoded_response_type& encoded) const
-{
-    lookup_in_response response{ std::move(ctx) };
-    if (encoded.status() == protocol::status::subdoc_success_deleted ||
-        encoded.status() == protocol::status::subdoc_multi_path_failure_deleted) {
-        response.deleted = true;
-    }
-    if (!response.ctx.ec) {
-        response.fields.resize(specs.entries.size());
-        for (size_t i = 0; i < specs.entries.size(); ++i) {
-            const auto& req_entry = specs.entries[i];
-            response.fields[i].original_index = req_entry.original_index;
-            response.fields[i].opcode = protocol::subdoc_opcode(req_entry.opcode);
-            response.fields[i].path = req_entry.path;
-            response.fields[i].status = protocol::status::success;
-        }
-        for (size_t i = 0; i < encoded.body().fields().size(); ++i) {
-            const auto& res_entry = encoded.body().fields()[i];
-            response.fields[i].status = res_entry.status;
-            response.fields[i].ec =
-              protocol::map_status_code(protocol::client_opcode::subdoc_multi_mutation, std::uint16_t(res_entry.status));
-            response.fields[i].exists =
-              res_entry.status == protocol::status::success || res_entry.status == protocol::status::subdoc_success_deleted;
-            response.fields[i].value = res_entry.value;
-            if (!response.fields[i].ec && !response.ctx.ec) {
-                response.ctx.ec = response.fields[i].ec;
-            }
-        }
-        if (!response.ctx.ec) {
-            response.cas = encoded.cas();
-        }
-        std::sort(response.fields.begin(), response.fields.end(), [](const auto& lhs, const auto& rhs) {
-            return lhs.original_index < rhs.original_index;
-        });
-    }
-    return response;
-}
-} // namespace couchbase::operations