couchbase 3.0.0.alpha.2 → 3.0.0.alpha.3

data/ext/couchbase/operations/document_decrement.hxx

@@ -43,6 +43,7 @@ struct decrement_request {
     std::optional<std::uint64_t> initial_value{};
     protocol::durability_level durability_level{ protocol::durability_level::none };
     std::optional<std::uint16_t> durability_timeout{};
+    std::chrono::milliseconds timeout{ timeout_defaults::key_value_timeout };
 
     void encode_to(encoded_request_type& encoded)
     {

data/ext/couchbase/operations/document_exists.hxx

@@ -40,6 +40,7 @@ struct exists_request {
     document_id id;
     std::uint16_t partition{};
     std::uint32_t opaque{};
+    std::chrono::milliseconds timeout{ timeout_defaults::key_value_timeout };
 
     void encode_to(encoded_request_type& encoded)
     {

data/ext/couchbase/operations/document_get.hxx

@@ -38,6 +38,7 @@ struct get_request {
     document_id id;
     uint16_t partition{};
     uint32_t opaque{};
+    std::chrono::milliseconds timeout{ timeout_defaults::key_value_timeout };
 
     void encode_to(encoded_request_type& encoded)
     {

data/ext/couchbase/operations/document_get_and_lock.hxx

@@ -39,6 +39,7 @@ struct get_and_lock_request {
     uint16_t partition{};
     uint32_t opaque{};
     uint32_t lock_time{};
+    std::chrono::milliseconds timeout{ timeout_defaults::key_value_timeout };
 
     void encode_to(encoded_request_type& encoded)
     {

data/ext/couchbase/operations/document_get_and_touch.hxx

@@ -39,6 +39,7 @@ struct get_and_touch_request {
     uint16_t partition{};
     uint32_t opaque{};
     uint32_t expiration{};
+    std::chrono::milliseconds timeout{ timeout_defaults::key_value_timeout };
 
     void encode_to(encoded_request_type& encoded)
     {

data/ext/couchbase/operations/document_get_projected.hxx

@@ -0,0 +1,243 @@
+/* -*- Mode: C++; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */
+/*
+ *     Copyright 2020 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 <document_id.hxx>
+#include <protocol/cmd_lookup_in.hxx>
+
+namespace couchbase::operations
+{
+
+struct get_projected_response {
+    document_id id;
+    std::error_code ec{};
+    std::string value{};
+    std::uint64_t cas{};
+    std::uint32_t flags{};
+    std::optional<std::uint32_t> expiration{};
+};
+
+struct get_projected_request {
+    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_expiration{ false };
+    std::vector<std::string> effective_projections{};
+    bool preserve_array_indexes{ false };
+    std::chrono::milliseconds timeout{ timeout_defaults::key_value_timeout };
+
+    void encode_to(encoded_request_type& encoded)
+    {
+        encoded.opaque(opaque);
+        encoded.partition(partition);
+        encoded.body().id(id);
+
+        effective_projections = projections;
+        std::size_t num_projections = effective_projections.size();
+        if (with_expiration) {
+            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_expiration) {
+            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);
+    }
+};
+
+namespace priv
+{
+
+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);
+            auto* val = cur->find(key);
+            if (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);
+            int array_index = std::stoi(key);
+            if (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 {};
+}
+
+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;
+    }
+}
+} // namespace priv
+
+get_projected_response
+make_response(std::error_code ec, get_projected_request& request, get_projected_request::encoded_response_type encoded)
+{
+    get_projected_response response{ request.id, ec };
+    if (!ec) {
+        response.cas = encoded.cas();
+        if (request.with_expiration) {
+            response.expiration = gsl::narrow_cast<std::uint32_t>(std::stoul(encoded.body().fields()[0].value));
+        }
+        if (request.effective_projections.empty()) {
+            // from full document
+            if (request.projections.empty() && request.with_expiration) {
+                // special case when user only wanted full+expiration
+                response.value = encoded.body().fields()[1].value;
+            } else {
+                tao::json::value full_doc = tao::json::from_string(encoded.body().fields()[request.with_expiration ? 1 : 0].value);
+                tao::json::value new_doc;
+                for (const auto& projection : request.projections) {
+                    auto value_to_apply = priv::subdoc_lookup(full_doc, projection);
+                    if (value_to_apply) {
+                        priv::subdoc_apply_projection(new_doc, projection, *value_to_apply, request.preserve_array_indexes);
+                    } else {
+                        response.ec = std::make_error_code(error::key_value_errc::path_not_found);
+                        return response;
+                    }
+                }
+                response.value = tao::json::to_string(new_doc);
+            }
+        } else {
+            tao::json::value new_doc = tao::json::empty_object;
+            std::size_t offset = request.with_expiration ? 1 : 0;
+            for (const auto& projection : request.projections) {
+                auto& field = encoded.body().fields()[offset++];
+                if (field.status == protocol::status::success && !field.value.empty()) {
+                    auto value_to_apply = tao::json::from_string(field.value);
+                    priv::subdoc_apply_projection(new_doc, projection, value_to_apply, request.preserve_array_indexes);
+                } else {
+                    response.ec = std::make_error_code(error::key_value_errc::path_not_found);
+                    return response;
+                }
+            }
+            response.value = tao::json::to_string(new_doc);
+        }
+    }
+    return response;
+}
+
+} // namespace couchbase::operations

data/ext/couchbase/operations/document_increment.hxx

@@ -17,8 +17,10 @@
 
 #pragma once
 
-#include <document_id.hxx>
 #include <protocol/cmd_increment.hxx>
+#include <protocol/durability_level.hxx>
+#include <operations.hxx>
+#include <protocol/client_response.hxx>
 
 namespace couchbase::operations
 {
@@ -43,6 +45,7 @@ struct increment_request {
     std::optional<std::uint64_t> initial_value{};
     protocol::durability_level durability_level{ protocol::durability_level::none };
     std::optional<std::uint16_t> durability_timeout{};
+    std::chrono::milliseconds timeout{ timeout_defaults::key_value_timeout };
 
     void encode_to(encoded_request_type& encoded)
     {

data/ext/couchbase/operations/document_insert.hxx

@@ -43,6 +43,7 @@ struct insert_request {
     uint32_t expiration{ 0 };
     protocol::durability_level durability_level{ protocol::durability_level::none };
     std::optional<std::uint16_t> durability_timeout{};
+    std::chrono::milliseconds timeout{ timeout_defaults::key_value_timeout };
 
     void encode_to(encoded_request_type& encoded)
     {

data/ext/couchbase/operations/document_lookup_in.hxx

@@ -47,6 +47,7 @@ struct lookup_in_request {
     uint32_t opaque{};
     bool access_deleted{ false };
     protocol::lookup_in_request_body::lookup_in_specs specs{};
+    std::chrono::milliseconds timeout{ timeout_defaults::key_value_timeout };
 
     void encode_to(encoded_request_type& encoded)
     {

data/ext/couchbase/operations/document_mutate_in.hxx

@@ -50,6 +50,7 @@ struct mutate_in_request {
     protocol::mutate_in_request_body::mutate_in_specs specs{};
     protocol::durability_level durability_level{ protocol::durability_level::none };
     std::optional<std::uint16_t> durability_timeout{};
+    std::chrono::milliseconds timeout{ timeout_defaults::key_value_timeout };
 
     void encode_to(encoded_request_type& encoded)
     {

data/ext/couchbase/operations/document_query.hxx

@@ -17,10 +17,21 @@
 
 #pragma once
 
+#include <gsl/gsl>
+
+#include <spdlog/spdlog.h>
+
 #include <tao/json.hpp>
 
 #include <version.hxx>
 
+#include <errors.hxx>
+#include <mutation_token.hxx>
+#include <service_type.hxx>
+#include <platform/uuid.h>
+#include <timeout_defaults.hxx>
+#include <io/http_message.hxx>
+
 namespace couchbase::operations
 {
 struct query_response_payload {
@@ -142,7 +153,6 @@ struct query_request {
 
     static const inline service_type type = service_type::query;
 
-    std::uint64_t timeout{ 75'000 }; // milliseconds
     std::string statement;
     std::string client_context_id{ uuid::to_string(uuid::random()) };
 
@@ -157,6 +167,7 @@ struct query_request {
     std::optional<std::uint64_t> pipeline_cap{};
     std::optional<scan_consistency_type> scan_consistency{};
     std::vector<mutation_token> mutation_state{};
+    std::chrono::milliseconds timeout{ timeout_defaults::query_timeout };
 
     enum class profile_mode {
         off,
@@ -174,7 +185,7 @@ struct query_request {
         encoded.headers["content-type"] = "application/json";
         tao::json::value body{ { "statement", statement },
                                { "client_context_id", client_context_id },
-                               { "timeout", fmt::format("{}ms", timeout) } };
+                               { "timeout", fmt::format("{}ms", timeout.count()) } };
         if (positional_parameters.empty()) {
             for (auto& param : named_parameters) {
                 Expects(param.first.empty() == false);

data/ext/couchbase/operations/document_remove.hxx

@@ -39,6 +39,7 @@ struct remove_request {
     uint32_t opaque{};
     protocol::durability_level durability_level{ protocol::durability_level::none };
     std::optional<std::uint16_t> durability_timeout{};
+    std::chrono::milliseconds timeout{ timeout_defaults::key_value_timeout };
 
     void encode_to(encoded_request_type& encoded)
     {

data/ext/couchbase/operations/document_replace.hxx

@@ -44,6 +44,7 @@ struct replace_request {
     uint64_t cas{ 0 };
     protocol::durability_level durability_level{ protocol::durability_level::none };
     std::optional<std::uint16_t> durability_timeout{};
+    std::chrono::milliseconds timeout{ timeout_defaults::key_value_timeout };
 
     void encode_to(encoded_request_type& encoded)
     {

data/ext/couchbase/operations/document_search.hxx

@@ -0,0 +1,337 @@
+/* -*- Mode: C++; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */
+/*
+ *     Copyright 2020 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 <tao/json.hpp>
+
+#include <version.hxx>
+
+namespace couchbase::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{};
+    };
+
+    std::error_code ec;
+    std::string status{};
+    search_meta_data meta_data{};
+    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;
+
+    static const inline service_type type = service_type::search;
+
+    std::string client_context_id{ uuid::to_string(uuid::random()) };
+    std::chrono::milliseconds timeout{ timeout_defaults::management_timeout };
+
+    std::string index_name;
+    tao::json::value query;
+
+    std::optional<std::uint32_t> limit{};
+    std::optional<std::uint32_t> skip{};
+    bool explain{ false };
+
+    enum class highlight_style_type { html, ansi };
+    std::optional<highlight_style_type> highlight_style{};
+    std::vector<std::string> highlight_fields{};
+    std::vector<std::string> fields{};
+
+    enum class scan_consistency_type { not_bounded };
+    std::optional<scan_consistency_type> 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, tao::json::value> raw{};
+
+    void encode_to(encoded_request_type& encoded)
+    {
+        encoded.headers["content-type"] = "application/json";
+        encoded.headers["client-context-id"] = client_context_id;
+        tao::json::value body{ { "query", query }, { "explain", explain }, { "timeout", fmt::format("{}ms", timeout.count()) } };
+        if (limit) {
+            body["size"] = *limit;
+        }
+        if (skip) {
+            body["from"] = *skip;
+        }
+        if (highlight_style || !highlight_fields.empty()) {
+            tao::json::value highlight;
+            if (highlight_style) {
+                switch (*highlight_style) {
+                    case highlight_style_type::html:
+                        highlight["style"] = "html";
+                        break;
+                    case highlight_style_type::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(tao::json::from_string(spec));
+            }
+        }
+        if (!facets.empty()) {
+            body["facets"] = tao::json::empty_object;
+            for (const auto& facet : facets) {
+                body["facets"][facet.first] = tao::json::from_string(facet.second);
+            }
+        }
+
+        encoded.method = "POST";
+        encoded.path = fmt::format("/api/index/{}/query", index_name);
+        encoded.body = tao::json::to_string(body);
+    }
+};
+
+search_response
+make_response(std::error_code ec, search_request& request, search_request::encoded_response_type encoded)
+{
+    search_response response{ ec };
+    response.meta_data.client_context_id = request.client_context_id;
+    if (!ec) {
+        if (encoded.status_code == 200) {
+            auto payload = tao::json::from_string(encoded.body);
+            response.meta_data.metrics.took = std::chrono::nanoseconds(payload.at("took").get_unsigned());
+            response.meta_data.metrics.max_score = payload.at("max_score").as<double>();
+            response.meta_data.metrics.total_rows = payload.at("total_hits").get_unsigned();
+            auto status_prop = payload.at("status");
+            if (status_prop.is_string()) {
+                response.status = status_prop.get_string();
+                if (response.status == "ok") {
+                    return response;
+                }
+            } else if (status_prop.is_object()) {
+                response.meta_data.metrics.error_partition_count = status_prop.at("failed").get_unsigned();
+                response.meta_data.metrics.success_partition_count = status_prop.at("successful").get_unsigned();
+                const auto* errors = status_prop.find("errors");
+                if (errors != nullptr && errors->is_object()) {
+                    for (const auto& error : errors->get_object()) {
+                        response.meta_data.errors.emplace(error.first, error.second.get_string());
+                    }
+                }
+            } else {
+                response.ec = std::make_error_code(error::common_errc::internal_server_failure);
+                return response;
+            }
+            const auto* rows = payload.find("hits");
+            if (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").get_double();
+                    const auto* locations = entry.find("locations");
+                    if (locations != nullptr && locations->is_object()) {
+                        for (const auto& field : locations->get_object()) {
+                            for (const auto& term : field.second.get_object()) {
+                                for (const auto& loc : term.second.get_array()) {
+                                    search_response::search_location location{};
+                                    location.field = field.first;
+                                    location.term = term.first;
+                                    location.position = loc.at("pos").get_unsigned();
+                                    location.start_offset = loc.at("start").get_unsigned();
+                                    location.end_offset = loc.at("end").get_unsigned();
+                                    const auto* ap = loc.find("array_positions");
+                                    if (ap != nullptr && ap->is_array()) {
+                                        location.array_positions.emplace(ap->as<std::vector<std::uint64_t>>());
+                                    }
+                                    row.locations.emplace_back(location);
+                                }
+                            }
+                        }
+                    }
+                    const auto* fragments_map = entry.find("fragments");
+                    if (fragments_map != nullptr && fragments_map->is_object()) {
+                        for (const auto& field : fragments_map->get_object()) {
+                            row.fragments.emplace(field.first, field.second.as<std::vector<std::string>>());
+                        }
+                    }
+                    const auto* fields = entry.find("fields");
+                    if (fields != nullptr && fields->is_object()) {
+                        row.fields = tao::json::to_string(*fields);
+                    }
+                    const auto* explanation = entry.find("explanation");
+                    if (explanation != nullptr && explanation->is_object()) {
+                        row.explanation = tao::json::to_string(*explanation);
+                    }
+                    response.rows.emplace_back(row);
+                }
+            }
+            const auto* facets = payload.find("facets");
+            if (facets != nullptr && facets->is_object()) {
+                for (const auto& entry : facets->get_object()) {
+                    search_response::search_facet facet;
+                    facet.name = entry.first;
+                    facet.field = entry.second.at("field").get_string();
+                    facet.total = entry.second.at("total").get_unsigned();
+                    facet.missing = entry.second.at("missing").get_unsigned();
+                    facet.other = entry.second.at("other").get_unsigned();
+
+                    const auto& date_ranges = entry.second.find("date_ranges");
+                    if (date_ranges != nullptr && date_ranges->is_array()) {
+                        for (const auto& date_range : date_ranges->get_array()) {
+                            search_response::search_facet::date_range_facet drf;
+                            drf.name = date_range.at("name").get_string();
+                            drf.count = date_range.at("count").get_unsigned();
+                            const auto* start = date_range.find("start");
+                            if (start != nullptr && start->is_string()) {
+                                drf.start = start->get_string();
+                            }
+                            const auto* end = date_range.find("end");
+                            if (end != nullptr && end->is_string()) {
+                                drf.end = end->get_string();
+                            }
+                            facet.date_ranges.emplace_back(drf);
+                        }
+                    }
+
+                    const auto& numeric_ranges = entry.second.find("numeric_ranges");
+                    if (numeric_ranges != nullptr && numeric_ranges->is_array()) {
+                        for (const auto& numeric_range : numeric_ranges->get_array()) {
+                            search_response::search_facet::numeric_range_facet nrf;
+                            nrf.name = numeric_range.at("name").get_string();
+                            nrf.count = numeric_range.at("count").get_unsigned();
+                            const auto* min = numeric_range.find("min");
+                            if (min != nullptr) {
+                                if (min->is_double()) {
+                                    nrf.min = min->get_double();
+                                } else if (min->is_integer()) {
+                                    nrf.min = min->get_unsigned();
+                                }
+                            }
+                            const auto* max = numeric_range.find("max");
+                            if (max != nullptr) {
+                                if (max->is_double()) {
+                                    nrf.max = max->get_double();
+                                } else if (max->is_integer()) {
+                                    nrf.max = max->get_unsigned();
+                                }
+                            }
+                            facet.numeric_ranges.emplace_back(nrf);
+                        }
+                    }
+
+                    const auto& terms = entry.second.find("terms");
+                    if (terms != nullptr && terms->is_array()) {
+                        for (const auto& term : terms->get_array()) {
+                            search_response::search_facet::term_facet tf;
+                            tf.term = term.at("term").get_string();
+                            tf.count = term.at("count").get_unsigned();
+                            facet.terms.emplace_back(tf);
+                        }
+                    }
+
+                    response.facets.emplace_back(facet);
+                }
+            }
+            return response;
+        }
+        if (encoded.status_code == 400) {
+            auto payload = tao::json::from_string(encoded.body);
+            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.ec = std::make_error_code(error::common_errc::index_not_found);
+                return response;
+            }
+        }
+        response.ec = std::make_error_code(error::common_errc::internal_server_failure);
+    }
+    return response;
+}
+
+} // namespace couchbase::operations