couchbase 3.1.1 → 3.2.0

data/ext/couchbase/operations/document_remove.hxx

@@ -43,7 +43,7 @@ struct remove_request {
     std::chrono::milliseconds timeout{ timeout_defaults::key_value_timeout };
     io::retry_context<io::retry_strategy::best_effort> retries{ false };
 
-    [[nodiscard]] std::error_code encode_to(encoded_request_type& encoded, mcbp_context&&)
+    [[nodiscard]] std::error_code encode_to(encoded_request_type& encoded, mcbp_context&& /* context */) const
     {
         encoded.opaque(opaque);
         encoded.partition(partition);
@@ -57,9 +57,9 @@ struct remove_request {
 };
 
 remove_response
-make_response(error_context::key_value&& ctx, remove_request& request, remove_request::encoded_response_type&& encoded)
+make_response(error_context::key_value&& ctx, const remove_request& request, remove_request::encoded_response_type&& encoded)
 {
-    remove_response response{ ctx };
+    remove_response response{ std::move(ctx) };
     if (!response.ctx.ec) {
         response.cas = encoded.cas();
         response.token = encoded.body().token();

data/ext/couchbase/operations/document_replace.hxx

@@ -48,7 +48,7 @@ struct replace_request {
     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&&)
+    [[nodiscard]] std::error_code encode_to(encoded_request_type& encoded, mcbp_context&& /* context */) const
     {
         encoded.opaque(opaque);
         encoded.partition(partition);
@@ -68,9 +68,9 @@ struct replace_request {
 };
 
 replace_response
-make_response(error_context::key_value&& ctx, replace_request& request, replace_request::encoded_response_type&& encoded)
+make_response(error_context::key_value&& ctx, const replace_request& request, replace_request::encoded_response_type&& encoded)
 {
-    replace_response response{ ctx };
+    replace_response response{ std::move(ctx) };
     if (!response.ctx.ec) {
         response.cas = encoded.cas();
         response.token = encoded.body().token();

data/ext/couchbase/operations/document_search.hxx

@@ -119,6 +119,8 @@ struct search_request {
     std::optional<highlight_style_type> highlight_style{};
     std::vector<std::string> highlight_fields{};
     std::vector<std::string> fields{};
+    std::optional<std::string> scope_name{};
+    std::vector<std::string> collections{};
 
     enum class scan_consistency_type { not_bounded };
     std::optional<scan_consistency_type> scan_consistency{};
@@ -175,8 +177,8 @@ struct search_request {
         }
         if (!facets.empty()) {
             body["facets"] = tao::json::empty_object;
-            for (const auto& facet : facets) {
-                body["facets"][facet.first] = tao::json::from_string(facet.second);
+            for (const auto& [name, facet] : facets) {
+                body["facets"][name] = tao::json::from_string(facet);
             }
         }
         if (!mutation_state.empty()) {
@@ -193,6 +195,10 @@ struct search_request {
                 { "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";
@@ -210,9 +216,9 @@ struct search_request {
 };
 
 search_response
-make_response(error_context::search&& ctx, search_request& request, search_request::encoded_response_type&& encoded)
+make_response(error_context::search&& ctx, const search_request& request, search_request::encoded_response_type&& encoded)
 {
-    search_response response{ ctx };
+    search_response response{ std::move(ctx) };
     response.meta_data.client_context_id = request.client_context_id;
     response.ctx.index_name = request.index_name;
     response.ctx.query = tao::json::to_string(request.query);
@@ -222,15 +228,15 @@ make_response(error_context::search&& ctx, search_request& request, search_reque
             tao::json::value payload{};
             try {
                 payload = tao::json::from_string(encoded.body);
-            } catch (tao::json::pegtl::parse_error& e) {
-                response.ctx.ec = std::make_error_code(error::common_errc::parsing_failure);
+            } catch (const tao::json::pegtl::parse_error& e) {
+                response.ctx.ec = error::common_errc::parsing_failure;
                 return response;
             }
             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()) {
+
+            if (auto& status_prop = payload.at("status"); status_prop.is_string()) {
                 response.status = status_prop.get_string();
                 if (response.status == "ok") {
                     return response;
@@ -238,36 +244,33 @@ make_response(error_context::search&& ctx, search_request& request, search_reque
             } 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());
+                if (const auto* errors = status_prop.find("errors"); errors != nullptr && errors->is_object()) {
+                    for (const auto& [location, message] : errors->get_object()) {
+                        response.meta_data.errors.try_emplace(location, message.get_string());
                     }
                 }
             } else {
-                response.ctx.ec = std::make_error_code(error::common_errc::internal_server_failure);
+                response.ctx.ec = error::common_errc::internal_server_failure;
                 return response;
             }
-            const auto* rows = payload.find("hits");
-            if (rows != nullptr && rows->is_array()) {
+
+            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>();
-                    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()) {
+                    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.first;
-                                    location.term = term.first;
+                                    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();
-                                    const auto* ap = loc.find("array_positions");
-                                    if (ap != nullptr && ap->is_array()) {
+                                    if (const auto* ap = loc.find("array_positions"); ap != nullptr && ap->is_array()) {
                                         location.array_positions.emplace(ap->as<std::vector<std::uint64_t>>());
                                     }
                                     row.locations.emplace_back(location);
@@ -275,67 +278,60 @@ make_response(error_context::search&& ctx, search_request& request, search_reque
                             }
                         }
                     }
-                    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>>());
+
+                    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.emplace(field, fragments.as<std::vector<std::string>>());
                         }
                     }
-                    const auto* fields = entry.find("fields");
-                    if (fields != nullptr && fields->is_object()) {
+                    if (const auto* fields = entry.find("fields"); fields != nullptr && fields->is_object()) {
                         row.fields = tao::json::to_string(*fields);
                     }
-                    const auto* explanation = entry.find("explanation");
-                    if (explanation != nullptr && explanation->is_object()) {
+                    if (const auto* explanation = entry.find("explanation"); 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()) {
+
+            if (const auto* facets = payload.find("facets"); facets != nullptr && facets->is_object()) {
+                for (const auto& [name, object] : 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()) {
+                    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 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()) {
+                            if (const auto* start = date_range.find("start"); start != nullptr && start->is_string()) {
                                 drf.start = start->get_string();
                             }
-                            const auto* end = date_range.find("end");
-                            if (end != nullptr && end->is_string()) {
+                            if (const auto* end = date_range.find("end"); 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()) {
+                    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 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 (const auto* min = numeric_range.find("min"); min != nullptr) {
                                 if (min->is_double()) {
                                     nrf.min = min->as<double>();
                                 } else if (min->is_integer()) {
                                     nrf.min = min->get_unsigned();
                                 }
                             }
-                            const auto* max = numeric_range.find("max");
-                            if (max != nullptr) {
+                            if (const auto* max = numeric_range.find("max"); max != nullptr) {
                                 if (max->is_double()) {
                                     nrf.max = max->as<double>();
                                 } else if (max->is_integer()) {
@@ -346,8 +342,7 @@ make_response(error_context::search&& ctx, search_request& request, search_reque
                         }
                     }
 
-                    const auto& terms = entry.second.find("terms");
-                    if (terms != nullptr && terms->is_array()) {
+                    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 tf;
                             tf.term = term.at("term").get_string();
@@ -365,26 +360,26 @@ make_response(error_context::search&& ctx, search_request& request, search_reque
             tao::json::value payload{};
             try {
                 payload = tao::json::from_string(encoded.body);
-            } catch (tao::json::pegtl::parse_error& e) {
-                response.ctx.ec = std::make_error_code(error::common_errc::parsing_failure);
+            } catch (const tao::json::pegtl::parse_error& e) {
+                response.ctx.ec = error::common_errc::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 = std::make_error_code(error::common_errc::index_not_found);
+                response.ctx.ec = error::common_errc::index_not_found;
                 return response;
             }
             if (response.error.find("no planPIndexes for indexName") != std::string::npos) {
-                response.ctx.ec = std::make_error_code(error::search_errc::index_not_ready);
+                response.ctx.ec = error::search_errc::index_not_ready;
                 return response;
             }
             if (response.error.find("pindex_consistency mismatched partition") != std::string::npos) {
-                response.ctx.ec = std::make_error_code(error::search_errc::consistency_mismatch);
+                response.ctx.ec = error::search_errc::consistency_mismatch;
                 return response;
             }
         }
-        response.ctx.ec = std::make_error_code(error::common_errc::internal_server_failure);
+        response.ctx.ec = error::common_errc::internal_server_failure;
     }
     return response;
 }

data/ext/couchbase/operations/document_touch.hxx

@@ -40,7 +40,7 @@ struct touch_request {
     std::chrono::milliseconds timeout{ timeout_defaults::key_value_timeout };
     io::retry_context<io::retry_strategy::best_effort> retries{ false };
 
-    [[nodiscard]] std::error_code encode_to(encoded_request_type& encoded, mcbp_context&&)
+    [[nodiscard]] std::error_code encode_to(encoded_request_type& encoded, mcbp_context&& /* context */) const
     {
         encoded.opaque(opaque);
         encoded.partition(partition);
@@ -51,9 +51,9 @@ struct touch_request {
 };
 
 touch_response
-make_response(error_context::key_value&& ctx, touch_request&, touch_request::encoded_response_type&& encoded)
+make_response(error_context::key_value&& ctx, const touch_request& /* request */, touch_request::encoded_response_type&& encoded)
 {
-    touch_response response{ ctx };
+    touch_response response{ std::move(ctx) };
     if (!response.ctx.ec) {
         response.cas = encoded.cas();
     }

data/ext/couchbase/operations/document_unlock.hxx

@@ -40,7 +40,7 @@ struct unlock_request {
     std::chrono::milliseconds timeout{ timeout_defaults::key_value_timeout };
     io::retry_context<io::retry_strategy::best_effort> retries{ false };
 
-    [[nodiscard]] std::error_code encode_to(encoded_request_type& encoded, mcbp_context&&)
+    [[nodiscard]] std::error_code encode_to(encoded_request_type& encoded, mcbp_context&& /* context */) const
     {
         encoded.opaque(opaque);
         encoded.partition(partition);
@@ -51,9 +51,9 @@ struct unlock_request {
 };
 
 unlock_response
-make_response(error_context::key_value&& ctx, unlock_request&, unlock_request::encoded_response_type&& encoded)
+make_response(error_context::key_value&& ctx, const unlock_request& /* request */, unlock_request::encoded_response_type&& encoded)
 {
-    unlock_response response{ ctx };
+    unlock_response response{ std::move(ctx) };
     if (!response.ctx.ec) {
         response.cas = encoded.cas();
     }

data/ext/couchbase/operations/document_upsert.hxx

@@ -47,7 +47,7 @@ struct upsert_request {
     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&&)
+    [[nodiscard]] std::error_code encode_to(encoded_request_type& encoded, mcbp_context&& /* context */) const
     {
         encoded.opaque(opaque);
         encoded.partition(partition);
@@ -66,9 +66,9 @@ struct upsert_request {
 };
 
 upsert_response
-make_response(error_context::key_value&& ctx, upsert_request& request, upsert_request::encoded_response_type&& encoded)
+make_response(error_context::key_value&& ctx, const upsert_request& request, upsert_request::encoded_response_type&& encoded)
 {
-    upsert_response response{ ctx };
+    upsert_response response{ std::move(ctx) };
     if (!response.ctx.ec) {
         response.cas = encoded.cas();
         response.token = encoded.body().token();

data/ext/couchbase/operations/document_view.hxx

@@ -53,7 +53,7 @@ struct document_view_request {
     using encoded_response_type = io::http_response;
     using error_context_type = error_context::view;
 
-    static const inline service_type type = service_type::views;
+    static const inline service_type type = service_type::view;
 
     std::string client_context_id{ uuid::to_string(uuid::random()) };
     std::chrono::milliseconds timeout{ timeout_defaults::management_timeout };
@@ -91,7 +91,7 @@ struct document_view_request {
     std::optional<sort_order> order;
     std::vector<std::string> query_string{};
 
-    [[nodiscard]] std::error_code encode_to(encoded_request_type& encoded, http_context&)
+    [[nodiscard]] std::error_code encode_to(encoded_request_type& encoded, http_context& /* context */)
     {
         if (debug) {
             query_string.emplace_back("debug=true");
@@ -177,9 +177,9 @@ struct document_view_request {
 };
 
 document_view_response
-make_response(error_context::view&& ctx, document_view_request& request, document_view_request::encoded_response_type&& encoded)
+make_response(error_context::view&& ctx, const document_view_request& request, document_view_request::encoded_response_type&& encoded)
 {
-    document_view_response response{ ctx };
+    document_view_response response{ std::move(ctx) };
     response.ctx.client_context_id = request.client_context_id;
     response.ctx.design_document_name = request.document_name;
     response.ctx.view_name = request.view_name;
@@ -189,24 +189,24 @@ make_response(error_context::view&& ctx, document_view_request& request, documen
             tao::json::value payload{};
             try {
                 payload = tao::json::from_string(encoded.body);
-            } catch (tao::json::pegtl::parse_error& e) {
-                response.ctx.ec = std::make_error_code(error::common_errc::parsing_failure);
+            } catch (const tao::json::pegtl::parse_error& e) {
+                response.ctx.ec = error::common_errc::parsing_failure;
                 return response;
             }
-            const auto* total_rows = payload.find("total_rows");
-            if (total_rows != nullptr && total_rows->is_unsigned()) {
+
+            if (const auto* total_rows = payload.find("total_rows"); total_rows != nullptr && total_rows->is_unsigned()) {
                 response.meta_data.total_rows = total_rows->get_unsigned();
             }
-            const auto* debug_info = payload.find("debug_info");
-            if (debug_info != nullptr && debug_info->is_object()) {
+
+            if (const auto* debug_info = payload.find("debug_info"); debug_info != nullptr && debug_info->is_object()) {
                 response.meta_data.debug_info.emplace(tao::json::to_string(*debug_info));
             }
-            const auto* rows = payload.find("rows");
-            if (rows != nullptr && rows->is_array()) {
+
+            if (const auto* rows = payload.find("rows"); rows != nullptr && rows->is_array()) {
                 for (const auto& entry : rows->get_array()) {
                     document_view_response::row row{};
-                    const auto* id = entry.find("id");
-                    if (id != nullptr && id->is_string()) {
+
+                    if (const auto* id = entry.find("id"); id != nullptr && id->is_string()) {
                         row.id = id->get_string();
                     }
                     row.key = tao::json::to_string(entry.at("key"));
@@ -218,25 +218,25 @@ make_response(error_context::view&& ctx, document_view_request& request, documen
             tao::json::value payload{};
             try {
                 payload = tao::json::from_string(encoded.body);
-            } catch (tao::json::pegtl::parse_error& e) {
-                response.ctx.ec = std::make_error_code(error::common_errc::parsing_failure);
+            } catch (const tao::json::pegtl::parse_error& e) {
+                response.ctx.ec = error::common_errc::parsing_failure;
                 return response;
             }
             document_view_response::problem problem{};
-            const auto* error = payload.find("error");
-            if (error != nullptr && error->is_string()) {
+
+            if (const auto* error = payload.find("error"); error != nullptr && error->is_string()) {
                 problem.code = error->get_string();
             }
-            const auto* reason = payload.find("reason");
-            if (reason != nullptr && reason->is_string()) {
+
+            if (const auto* reason = payload.find("reason"); reason != nullptr && reason->is_string()) {
                 problem.message = reason->get_string();
             }
             response.error.emplace(problem);
-            response.ctx.ec = std::make_error_code(error::common_errc::invalid_argument);
+            response.ctx.ec = error::common_errc::invalid_argument;
         } else if (encoded.status_code == 404) {
-            response.ctx.ec = std::make_error_code(error::view_errc::design_document_not_found);
+            response.ctx.ec = error::view_errc::design_document_not_found;
         } else {
-            response.ctx.ec = std::make_error_code(error::common_errc::internal_server_failure);
+            response.ctx.ec = error::common_errc::internal_server_failure;
         }
     }
     return response;

data/ext/couchbase/operations/group_drop.hxx

@@ -42,7 +42,7 @@ struct group_drop_request {
     std::chrono::milliseconds timeout{ timeout_defaults::management_timeout };
     std::string client_context_id{ uuid::to_string(uuid::random()) };
 
-    [[nodiscard]] std::error_code encode_to(encoded_request_type& encoded, http_context&)
+    [[nodiscard]] std::error_code encode_to(encoded_request_type& encoded, http_context& /* context */) const
     {
         encoded.method = "DELETE";
         encoded.path = fmt::format("/settings/rbac/groups/{}", name);
@@ -51,18 +51,18 @@ struct group_drop_request {
 };
 
 group_drop_response
-make_response(error_context::http&& ctx, group_drop_request&, group_drop_request::encoded_response_type&& encoded)
+make_response(error_context::http&& ctx, const group_drop_request& /* request */, group_drop_request::encoded_response_type&& encoded)
 {
-    group_drop_response response{ ctx };
+    group_drop_response response{ std::move(ctx) };
     if (!response.ctx.ec) {
         switch (encoded.status_code) {
             case 200:
                 break;
             case 404:
-                response.ctx.ec = std::make_error_code(error::management_errc::group_not_found);
+                response.ctx.ec = error::management_errc::group_not_found;
                 break;
             default:
-                response.ctx.ec = std::make_error_code(error::common_errc::internal_server_failure);
+                response.ctx.ec = error::common_errc::internal_server_failure;
                 break;
         }
     }