couchbase 3.1.1-universal-darwin-20 → 3.2.0-universal-darwin-20

data/ext/couchbase/operations/group_get.hxx

@@ -43,7 +43,7 @@ struct group_get_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 = "GET";
         encoded.path = fmt::format("/settings/rbac/groups/{}", name);
@@ -53,24 +53,24 @@ struct group_get_request {
 };
 
 group_get_response
-make_response(error_context::http&& ctx, group_get_request&, group_get_request::encoded_response_type&& encoded)
+make_response(error_context::http&& ctx, const group_get_request& /* request */, group_get_request::encoded_response_type&& encoded)
 {
-    group_get_response response{ ctx };
+    group_get_response response{ std::move(ctx) };
     if (!response.ctx.ec) {
         switch (encoded.status_code) {
             case 200: {
                 try {
                     response.group = tao::json::from_string(encoded.body).as<rbac::group>();
-                } 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;
                 }
             } 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;
         }
     }

data/ext/couchbase/operations/group_get_all.hxx

@@ -42,7 +42,7 @@ struct group_get_all_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 = "GET";
         encoded.path = fmt::format("/settings/rbac/groups");
@@ -52,23 +52,23 @@ struct group_get_all_request {
 };
 
 group_get_all_response
-make_response(error_context::http&& ctx, group_get_all_request&, group_get_all_request::encoded_response_type&& encoded)
+make_response(error_context::http&& ctx, const group_get_all_request& /* request */, group_get_all_request::encoded_response_type&& encoded)
 {
-    group_get_all_response response{ ctx };
+    group_get_all_response response{ std::move(ctx) };
     if (!response.ctx.ec) {
         if (encoded.status_code == 200) {
             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;
             }
             for (const auto& entry : payload.get_array()) {
                 response.groups.emplace_back(entry.as<rbac::group>());
             }
         } 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_upsert.hxx

@@ -47,7 +47,7 @@ struct group_upsert_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 = "PUT";
         encoded.path = fmt::format("/settings/rbac/groups/{}", group.name);
@@ -91,31 +91,31 @@ struct group_upsert_request {
 };
 
 group_upsert_response
-make_response(error_context::http&& ctx, group_upsert_request&, group_upsert_request::encoded_response_type&& encoded)
+make_response(error_context::http&& ctx, const group_upsert_request& /* request */, group_upsert_request::encoded_response_type&& encoded)
 {
-    group_upsert_response response{ ctx };
+    group_upsert_response response{ std::move(ctx) };
     if (!response.ctx.ec) {
         switch (encoded.status_code) {
             case 200:
                 break;
             case 400: {
-                response.ctx.ec = std::make_error_code(error::common_errc::invalid_argument);
+                response.ctx.ec = error::common_errc::invalid_argument;
                 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&) {
+                    response.ctx.ec = error::common_errc::parsing_failure;
                     return response;
                 }
-                const auto* errors = payload.find("errors");
-                if (errors != nullptr && errors->is_object()) {
-                    for (const auto& entry : errors->get_object()) {
-                        response.errors.emplace_back(fmt::format("{}: {}", entry.first, entry.second.get_string()));
+
+                if (const auto* errors = payload.find("errors"); errors != nullptr && errors->is_object()) {
+                    for (const auto& [code, message] : errors->get_object()) {
+                        response.errors.emplace_back(fmt::format("{}: {}", code, message.get_string()));
                     }
                 }
             } 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;
         }
     }

data/ext/couchbase/operations/http_noop.hxx

@@ -39,7 +39,7 @@ struct http_noop_request {
 
     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 */)
     {
         encoded.headers["connection"] = "keep-alive";
         encoded.method = "GET";
@@ -56,22 +56,22 @@ struct http_noop_request {
                 timeout = timeout_defaults::search_timeout;
                 encoded.path = "/api/ping";
                 break;
-            case service_type::views:
+            case service_type::view:
                 timeout = timeout_defaults::view_timeout;
                 encoded.path = "/";
                 break;
             case service_type::management:
-            case service_type::kv:
-                return std::make_error_code(error::common_errc::feature_not_available);
+            case service_type::key_value:
+                return error::common_errc::feature_not_available;
         }
         return {};
     }
 };
 
 http_noop_response
-make_response(error_context::http&& ctx, http_noop_request&, http_noop_request::encoded_response_type&&)
+make_response(error_context::http&& ctx, const http_noop_request& /* request */, http_noop_request::encoded_response_type&&)
 {
-    http_noop_response response{ ctx };
+    http_noop_response response{ std::move(ctx) };
     return response;
 }
 

data/ext/couchbase/operations/mcbp_noop.hxx

@@ -37,7 +37,7 @@ struct mcbp_noop_request {
     std::chrono::milliseconds timeout{ timeout_defaults::key_value_timeout };
     io::retry_context<io::retry_strategy::best_effort> retries{ true };
 
-    [[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);
@@ -46,9 +46,9 @@ struct mcbp_noop_request {
 };
 
 mcbp_noop_response
-make_response(error_context::key_value&& ctx, mcbp_noop_request&, mcbp_noop_request::encoded_response_type&&)
+make_response(error_context::key_value&& ctx, const mcbp_noop_request& /* request */, mcbp_noop_request::encoded_response_type&&)
 {
-    mcbp_noop_response response{ ctx };
+    mcbp_noop_response response{ std::move(ctx) };
     return response;
 }
 

data/ext/couchbase/operations/query_index_build_deferred.hxx

@@ -45,7 +45,7 @@ struct query_index_build_deferred_request {
     std::string bucket_name;
     std::chrono::milliseconds timeout{ timeout_defaults::management_timeout };
 
-    [[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.headers["content-type"] = "application/json";
         tao::json::value body{
@@ -64,16 +64,16 @@ struct query_index_build_deferred_request {
 
 query_index_build_deferred_response
 make_response(error_context::http&& ctx,
-              query_index_build_deferred_request&,
+              const query_index_build_deferred_request& /* request */,
               query_index_build_deferred_request::encoded_response_type&& encoded)
 {
-    query_index_build_deferred_response response{ ctx };
+    query_index_build_deferred_response response{ std::move(ctx) };
     if (!response.ctx.ec) {
         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();
@@ -84,7 +84,7 @@ make_response(error_context::http&& ctx,
                 error.message = entry.at("msg").get_string();
                 response.errors.emplace_back(error);
             }
-            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/query_index_create.hxx

@@ -55,7 +55,7 @@ struct query_index_create_request {
     std::optional<int> num_replicas{};
     std::chrono::milliseconds timeout{ timeout_defaults::management_timeout };
 
-    [[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.headers["content-type"] = "application/json";
         tao::json::value with{};
@@ -100,15 +100,17 @@ struct query_index_create_request {
 };
 
 query_index_create_response
-make_response(error_context::http&& ctx, query_index_create_request& request, query_index_create_request::encoded_response_type&& encoded)
+make_response(error_context::http&& ctx,
+              const query_index_create_request& request,
+              query_index_create_request::encoded_response_type&& encoded)
 {
-    query_index_create_response response{ ctx };
+    query_index_create_response response{ std::move(ctx) };
     if (!response.ctx.ec) {
         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();
@@ -137,12 +139,12 @@ make_response(error_context::http&& ctx, query_index_create_request& request, qu
             }
             if (index_already_exists) {
                 if (!request.ignore_if_exists) {
-                    response.ctx.ec = std::make_error_code(error::common_errc::index_exists);
+                    response.ctx.ec = error::common_errc::index_exists;
                 }
             } else if (bucket_not_found) {
-                response.ctx.ec = std::make_error_code(error::common_errc::bucket_not_found);
+                response.ctx.ec = error::common_errc::bucket_not_found;
             } else if (!response.errors.empty()) {
-                response.ctx.ec = std::make_error_code(error::common_errc::internal_server_failure);
+                response.ctx.ec = error::common_errc::internal_server_failure;
             }
         }
     }

data/ext/couchbase/operations/query_index_drop.hxx

@@ -51,7 +51,7 @@ struct query_index_drop_request {
     bool ignore_if_does_not_exist{ false };
     std::chrono::milliseconds timeout{ timeout_defaults::management_timeout };
 
-    [[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.headers["content-type"] = "application/json";
         std::string keyspace = fmt::format("`{}`", bucket_name);
@@ -73,15 +73,15 @@ struct query_index_drop_request {
 };
 
 query_index_drop_response
-make_response(error_context::http&& ctx, query_index_drop_request& request, query_index_drop_request::encoded_response_type&& encoded)
+make_response(error_context::http&& ctx, const query_index_drop_request& request, query_index_drop_request::encoded_response_type&& encoded)
 {
-    query_index_drop_response response{ ctx };
+    query_index_drop_response response{ std::move(ctx) };
     if (!response.ctx.ec) {
         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();
@@ -111,12 +111,12 @@ make_response(error_context::http&& ctx, query_index_drop_request& request, quer
             }
             if (index_not_found) {
                 if (!request.ignore_if_does_not_exist) {
-                    response.ctx.ec = std::make_error_code(error::common_errc::index_not_found);
+                    response.ctx.ec = error::common_errc::index_not_found;
                 }
             } else if (bucket_not_found) {
-                response.ctx.ec = std::make_error_code(error::common_errc::bucket_not_found);
+                response.ctx.ec = error::common_errc::bucket_not_found;
             } else if (!response.errors.empty()) {
-                response.ctx.ec = std::make_error_code(error::common_errc::internal_server_failure);
+                response.ctx.ec = error::common_errc::internal_server_failure;
             }
         }
     }

data/ext/couchbase/operations/query_index_get_all.hxx

@@ -35,6 +35,7 @@ struct query_index_get_all_response {
         std::string collection_name;
         std::string type;
         std::vector<std::string> index_key{};
+        std::optional<std::string> partition{};
         std::optional<std::string> condition{};
         std::optional<std::string> bucket_id{};
         std::optional<std::string> scope_id{};
@@ -56,7 +57,7 @@ struct query_index_get_all_request {
     std::string bucket_name;
     std::chrono::milliseconds timeout{ timeout_defaults::management_timeout };
 
-    [[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.headers["content-type"] = "application/json";
         tao::json::value body{
@@ -75,46 +76,49 @@ struct query_index_get_all_request {
 };
 
 query_index_get_all_response
-make_response(error_context::http&& ctx, query_index_get_all_request&, query_index_get_all_request::encoded_response_type&& encoded)
+make_response(error_context::http&& ctx,
+              const query_index_get_all_request& /* request */,
+              query_index_get_all_request::encoded_response_type&& encoded)
 {
-    query_index_get_all_response response{ ctx };
-    if (!response.ctx.ec) {
-        if (encoded.status_code == 200) {
-            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);
-                return response;
-            }
-            response.status = payload.at("status").get_string();
-            if (response.status == "success") {
-                for (const auto& entry : payload.at("results").get_array()) {
-                    query_index_get_all_response::query_index index;
-                    index.id = entry.at("id").get_string();
-                    index.datastore_id = entry.at("datastore_id").get_string();
-                    index.namespace_id = entry.at("namespace_id").get_string();
-                    index.keyspace_id = entry.at("keyspace_id").get_string();
-                    index.type = entry.at("using").get_string();
-                    index.name = entry.at("name").get_string();
-                    index.state = entry.at("state").get_string();
-                    if (const auto* prop = entry.find("bucket_id")) {
-                        index.bucket_id = prop->get_string();
-                    }
-                    if (const auto* prop = entry.find("scope_id")) {
-                        index.scope_id = prop->get_string();
-                    }
-                    if (const auto* prop = entry.find("is_primary")) {
-                        index.is_primary = prop->get_boolean();
-                    }
-                    if (const auto* prop = entry.find("condition")) {
-                        index.condition = prop->get_string();
-                    }
-                    for (const auto& key : entry.at("index_key").get_array()) {
-                        index.index_key.emplace_back(key.get_string());
-                    }
-                    response.indexes.emplace_back(index);
+    query_index_get_all_response response{ std::move(ctx) };
+    if (!response.ctx.ec && encoded.status_code == 200) {
+        tao::json::value payload{};
+        try {
+            payload = tao::json::from_string(encoded.body);
+        } 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();
+        if (response.status == "success") {
+            for (const auto& entry : payload.at("results").get_array()) {
+                query_index_get_all_response::query_index index;
+                index.id = entry.at("id").get_string();
+                index.datastore_id = entry.at("datastore_id").get_string();
+                index.namespace_id = entry.at("namespace_id").get_string();
+                index.keyspace_id = entry.at("keyspace_id").get_string();
+                index.type = entry.at("using").get_string();
+                index.name = entry.at("name").get_string();
+                index.state = entry.at("state").get_string();
+                if (const auto* prop = entry.find("bucket_id")) {
+                    index.bucket_id = prop->get_string();
+                }
+                if (const auto* prop = entry.find("scope_id")) {
+                    index.scope_id = prop->get_string();
+                }
+                if (const auto* prop = entry.find("is_primary")) {
+                    index.is_primary = prop->get_boolean();
+                }
+                if (const auto* prop = entry.find("condition")) {
+                    index.condition = prop->get_string();
+                }
+                if (const auto* prop = entry.find("partition")) {
+                    index.partition = prop->get_string();
+                }
+                for (const auto& key : entry.at("index_key").get_array()) {
+                    index.index_key.emplace_back(key.get_string());
                 }
+                response.indexes.emplace_back(index);
             }
         }
     }

data/ext/couchbase/operations/rbac.hxx

@@ -84,8 +84,7 @@ struct traits<couchbase::operations::rbac::user_and_metadata> {
     static couchbase::operations::rbac::user_and_metadata as(const tao::json::basic_value<Traits>& v)
     {
         couchbase::operations::rbac::user_and_metadata result;
-        std::string domain = v.at("domain").get_string();
-        if (domain == "local") {
+        if (const std::string& domain = v.at("domain").get_string(); domain == "local") {
             result.domain = couchbase::operations::rbac::auth_domain::local;
         } else if (domain == "external") {
             result.domain = couchbase::operations::rbac::auth_domain::external;
@@ -93,78 +92,56 @@ struct traits<couchbase::operations::rbac::user_and_metadata> {
             spdlog::error(R"("unexpected domain for user with metadata: "{}")", domain);
         }
         result.username = v.at("id").get_string();
-        {
-            const auto* display_name = v.find("name");
-            if (display_name != nullptr && !display_name->get_string().empty()) {
-                result.display_name = display_name->get_string();
-            }
+        if (const auto* display_name = v.find("name"); display_name != nullptr && !display_name->get_string().empty()) {
+            result.display_name = display_name->get_string();
         }
         result.password_changed = v.template optional<std::string>("password_change_date");
-        {
-            const auto* external_groups = v.find("external_groups");
-            if (external_groups != nullptr) {
-                for (const auto& group : external_groups->get_array()) {
-                    result.external_groups.insert(group.get_string());
-                }
+        if (const auto* external_groups = v.find("external_groups"); external_groups != nullptr) {
+            for (const auto& group : external_groups->get_array()) {
+                result.external_groups.insert(group.get_string());
             }
         }
-        {
-            const auto* groups = v.find("groups");
-            if (groups != nullptr) {
-                for (const auto& group : groups->get_array()) {
-                    result.groups.insert(group.get_string());
-                }
+        if (const auto* groups = v.find("groups"); groups != nullptr) {
+            for (const auto& group : groups->get_array()) {
+                result.groups.insert(group.get_string());
             }
         }
-        {
-            const auto* roles = v.find("roles");
-            if (roles != nullptr) {
-                for (const auto& entry : roles->get_array()) {
-                    couchbase::operations::rbac::role_and_origins role{};
-                    role.name = entry.at("role").get_string();
-                    {
-                        const auto* bucket = entry.find("bucket_name");
-                        if (bucket != nullptr && !bucket->get_string().empty()) {
-                            role.bucket = bucket->get_string();
-                        }
-                    }
-                    {
-                        const auto* scope = entry.find("scope_name");
-                        if (scope != nullptr && !scope->get_string().empty()) {
-                            role.scope = scope->get_string();
+        if (const auto* roles = v.find("roles"); roles != nullptr) {
+            for (const auto& entry : roles->get_array()) {
+                couchbase::operations::rbac::role_and_origins role{};
+                role.name = entry.at("role").get_string();
+                if (const auto* bucket = entry.find("bucket_name"); bucket != nullptr && !bucket->get_string().empty()) {
+                    role.bucket = bucket->get_string();
+                }
+                if (const auto* scope = entry.find("scope_name"); scope != nullptr && !scope->get_string().empty()) {
+                    role.scope = scope->get_string();
+                }
+
+                if (const auto* collection = entry.find("collection_name"); collection != nullptr && !collection->get_string().empty()) {
+                    role.collection = collection->get_string();
+                }
+
+                if (const auto* origins = entry.find("origins"); origins != nullptr) {
+                    bool has_user_origin = false;
+                    for (const auto& ent : origins->get_array()) {
+                        couchbase::operations::rbac::origin origin{};
+                        origin.type = ent.at("type").get_string();
+                        if (origin.type == "user") {
+                            has_user_origin = true;
                         }
-                    }
-                    {
-                        const auto* collection = entry.find("collection_name");
-                        if (collection != nullptr && !collection->get_string().empty()) {
-                            role.collection = collection->get_string();
+                        const auto* name = ent.find("name");
+                        if (name != nullptr) {
+                            origin.name = name->get_string();
                         }
+                        role.origins.push_back(origin);
                     }
-                    {
-                        const auto* origins = entry.find("origins");
-                        if (origins != nullptr) {
-                            bool has_user_origin = false;
-                            for (const auto& ent : origins->get_array()) {
-                                couchbase::operations::rbac::origin origin{};
-                                origin.type = ent.at("type").get_string();
-                                if (origin.type == "user") {
-                                    has_user_origin = true;
-                                }
-                                const auto* name = ent.find("name");
-                                if (name != nullptr) {
-                                    origin.name = name->get_string();
-                                }
-                                role.origins.push_back(origin);
-                            }
-                            if (has_user_origin) {
-                                result.roles.push_back(role);
-                            }
-                        } else {
-                            result.roles.push_back(role);
-                        }
+                    if (has_user_origin) {
+                        result.roles.push_back(role);
                     }
-                    result.effective_roles.push_back(role);
+                } else {
+                    result.roles.push_back(role);
                 }
+                result.effective_roles.push_back(role);
             }
         }
         return result;