couchbase 3.0.1 → 3.0.2

data/ext/couchbase/operations.hxx

@@ -26,6 +26,8 @@
 #include <operations/document_insert.hxx>
 #include <operations/document_upsert.hxx>
 #include <operations/document_replace.hxx>
+#include <operations/document_append.hxx>
+#include <operations/document_prepend.hxx>
 #include <operations/document_remove.hxx>
 #include <operations/document_lookup_in.hxx>
 #include <operations/document_mutate_in.hxx>
@@ -36,6 +38,9 @@
 #include <operations/document_decrement.hxx>
 #include <operations/document_get_projected.hxx>
 
+#include <operations/mcbp_noop.hxx>
+#include <operations/http_noop.hxx>
+
 #include <operations/document_query.hxx>
 #include <operations/document_search.hxx>
 #include <operations/document_analytics.hxx>

data/ext/couchbase/operations/analytics_dataset_create.hxx

@@ -53,7 +53,7 @@ struct analytics_dataset_create_request {
 
     bool ignore_if_exists{ false };
 
-    void encode_to(encoded_request_type& encoded, http_context&)
+    [[nodiscard]] std::error_code encode_to(encoded_request_type& encoded, http_context&)
     {
         std::string where_clause = condition ? fmt::format("WHERE {}", *condition) : "";
         std::string if_not_exists_clause = ignore_if_exists ? "IF NOT EXISTS" : "";
@@ -67,13 +67,14 @@ struct analytics_dataset_create_request {
         encoded.method = "POST";
         encoded.path = "/analytics/service";
         encoded.body = tao::json::to_string(body);
+        return {};
     }
 };
 
 analytics_dataset_create_response
 make_response(std::error_code ec,
               analytics_dataset_create_request& request,
-              analytics_dataset_create_request::encoded_response_type encoded)
+              analytics_dataset_create_request::encoded_response_type&& encoded)
 {
     analytics_dataset_create_response response{ request.client_context_id, ec };
     if (!ec) {

data/ext/couchbase/operations/analytics_dataset_drop.hxx

@@ -50,7 +50,7 @@ struct analytics_dataset_drop_request {
 
     bool ignore_if_does_not_exist{ false };
 
-    void encode_to(encoded_request_type& encoded, http_context&)
+    [[nodiscard]] std::error_code encode_to(encoded_request_type& encoded, http_context&)
     {
         std::string if_exists_clause = ignore_if_does_not_exist ? "IF EXISTS" : "";
 
@@ -61,11 +61,12 @@ struct analytics_dataset_drop_request {
         encoded.method = "POST";
         encoded.path = "/analytics/service";
         encoded.body = tao::json::to_string(body);
+        return {};
     }
 };
 
 analytics_dataset_drop_response
-make_response(std::error_code ec, analytics_dataset_drop_request& request, analytics_dataset_drop_request::encoded_response_type encoded)
+make_response(std::error_code ec, analytics_dataset_drop_request& request, analytics_dataset_drop_request::encoded_response_type&& encoded)
 {
     analytics_dataset_drop_response response{ request.client_context_id, ec };
     if (!ec) {

data/ext/couchbase/operations/analytics_dataset_get_all.hxx

@@ -53,7 +53,7 @@ struct analytics_dataset_get_all_request {
     std::string client_context_id{ uuid::to_string(uuid::random()) };
     std::chrono::milliseconds timeout{ timeout_defaults::management_timeout };
 
-    void encode_to(encoded_request_type& encoded, http_context&)
+    [[nodiscard]] std::error_code encode_to(encoded_request_type& encoded, http_context&)
     {
         tao::json::value body{
             { "statement", "SELECT d.* FROM Metadata.`Dataset` d WHERE d.DataverseName <> \"Metadata\"" },
@@ -62,13 +62,14 @@ struct analytics_dataset_get_all_request {
         encoded.method = "POST";
         encoded.path = "/analytics/service";
         encoded.body = tao::json::to_string(body);
+        return {};
     }
 };
 
 analytics_dataset_get_all_response
 make_response(std::error_code ec,
               analytics_dataset_get_all_request& request,
-              analytics_dataset_get_all_request::encoded_response_type encoded)
+              analytics_dataset_get_all_request::encoded_response_type&& encoded)
 {
     analytics_dataset_get_all_response response{ request.client_context_id, ec };
 

data/ext/couchbase/operations/analytics_dataverse_create.hxx

@@ -49,7 +49,7 @@ struct analytics_dataverse_create_request {
 
     bool ignore_if_exists{ false };
 
-    void encode_to(encoded_request_type& encoded, http_context&)
+    [[nodiscard]] std::error_code encode_to(encoded_request_type& encoded, http_context&)
     {
         std::string if_not_exists_clause = ignore_if_exists ? "IF NOT EXISTS" : "";
 
@@ -60,13 +60,14 @@ struct analytics_dataverse_create_request {
         encoded.method = "POST";
         encoded.path = "/analytics/service";
         encoded.body = tao::json::to_string(body);
+        return {};
     }
 };
 
 analytics_dataverse_create_response
 make_response(std::error_code ec,
               analytics_dataverse_create_request& request,
-              analytics_dataverse_create_request::encoded_response_type encoded)
+              analytics_dataverse_create_request::encoded_response_type&& encoded)
 {
     analytics_dataverse_create_response response{ request.client_context_id, ec };
     if (!ec) {

data/ext/couchbase/operations/analytics_dataverse_drop.hxx

@@ -49,7 +49,7 @@ struct analytics_dataverse_drop_request {
 
     bool ignore_if_does_not_exist{ false };
 
-    void encode_to(encoded_request_type& encoded, http_context&)
+    [[nodiscard]] std::error_code encode_to(encoded_request_type& encoded, http_context&)
     {
         std::string if_exists_clause = ignore_if_does_not_exist ? "IF EXISTS" : "";
 
@@ -60,13 +60,14 @@ struct analytics_dataverse_drop_request {
         encoded.method = "POST";
         encoded.path = "/analytics/service";
         encoded.body = tao::json::to_string(body);
+        return {};
     }
 };
 
 analytics_dataverse_drop_response
 make_response(std::error_code ec,
               analytics_dataverse_drop_request& request,
-              analytics_dataverse_drop_request::encoded_response_type encoded)
+              analytics_dataverse_drop_request::encoded_response_type&& encoded)
 {
     analytics_dataverse_drop_response response{ request.client_context_id, ec };
     if (!ec) {

data/ext/couchbase/operations/analytics_get_pending_mutations.hxx

@@ -46,17 +46,18 @@ struct analytics_get_pending_mutations_request {
     std::string client_context_id{ uuid::to_string(uuid::random()) };
     std::chrono::milliseconds timeout{ timeout_defaults::management_timeout };
 
-    void encode_to(encoded_request_type& encoded, http_context&)
+    [[nodiscard]] std::error_code encode_to(encoded_request_type& encoded, http_context&)
     {
         encoded.method = "GET";
         encoded.path = "/analytics/node/agg/stats/remaining";
+        return {};
     }
 };
 
 analytics_get_pending_mutations_response
 make_response(std::error_code ec,
               analytics_get_pending_mutations_request& request,
-              analytics_get_pending_mutations_request::encoded_response_type encoded)
+              analytics_get_pending_mutations_request::encoded_response_type&& encoded)
 {
     analytics_get_pending_mutations_response response{ request.client_context_id, ec };
     if (!ec) {

data/ext/couchbase/operations/analytics_index_create.hxx

@@ -52,7 +52,7 @@ struct analytics_index_create_request {
 
     bool ignore_if_exists{ false };
 
-    void encode_to(encoded_request_type& encoded, http_context&)
+    [[nodiscard]] std::error_code encode_to(encoded_request_type& encoded, http_context&)
     {
         std::string if_not_exists_clause = ignore_if_exists ? "IF NOT EXISTS" : "";
         std::vector<std::string> field_specs;
@@ -74,11 +74,12 @@ struct analytics_index_create_request {
         encoded.method = "POST";
         encoded.path = "/analytics/service";
         encoded.body = tao::json::to_string(body);
+        return {};
     }
 };
 
 analytics_index_create_response
-make_response(std::error_code ec, analytics_index_create_request& request, analytics_index_create_request::encoded_response_type encoded)
+make_response(std::error_code ec, analytics_index_create_request& request, analytics_index_create_request::encoded_response_type&& encoded)
 {
     analytics_index_create_response response{ request.client_context_id, ec };
     if (!ec) {

data/ext/couchbase/operations/analytics_index_drop.hxx

@@ -51,7 +51,7 @@ struct analytics_index_drop_request {
 
     bool ignore_if_does_not_exist{ false };
 
-    void encode_to(encoded_request_type& encoded, http_context&)
+    [[nodiscard]] std::error_code encode_to(encoded_request_type& encoded, http_context&)
     {
         std::string if_exists_clause = ignore_if_does_not_exist ? "IF EXISTS" : "";
 
@@ -62,11 +62,12 @@ struct analytics_index_drop_request {
         encoded.method = "POST";
         encoded.path = "/analytics/service";
         encoded.body = tao::json::to_string(body);
+        return {};
     }
 };
 
 analytics_index_drop_response
-make_response(std::error_code ec, analytics_index_drop_request& request, analytics_index_drop_request::encoded_response_type encoded)
+make_response(std::error_code ec, analytics_index_drop_request& request, analytics_index_drop_request::encoded_response_type&& encoded)
 {
     analytics_index_drop_response response{ request.client_context_id, ec };
     if (!ec) {

data/ext/couchbase/operations/analytics_index_get_all.hxx

@@ -53,7 +53,7 @@ struct analytics_index_get_all_request {
     std::string client_context_id{ uuid::to_string(uuid::random()) };
     std::chrono::milliseconds timeout{ timeout_defaults::management_timeout };
 
-    void encode_to(encoded_request_type& encoded, http_context&)
+    [[nodiscard]] std::error_code encode_to(encoded_request_type& encoded, http_context&)
     {
         tao::json::value body{
             { "statement", "SELECT d.* FROM Metadata.`Index` d WHERE d.DataverseName <> \"Metadata\"" },
@@ -63,11 +63,14 @@ struct analytics_index_get_all_request {
         encoded.method = "POST";
         encoded.path = "/analytics/service";
         encoded.body = tao::json::to_string(body);
+        return {};
     }
 };
 
 analytics_index_get_all_response
-make_response(std::error_code ec, analytics_index_get_all_request& request, analytics_index_get_all_request::encoded_response_type encoded)
+make_response(std::error_code ec,
+              analytics_index_get_all_request& request,
+              analytics_index_get_all_request::encoded_response_type&& encoded)
 {
     analytics_index_get_all_response response{ request.client_context_id, ec };
 

data/ext/couchbase/operations/analytics_link_connect.hxx

@@ -49,7 +49,7 @@ struct analytics_link_connect_request {
     std::string link_name;
     bool force{ false };
 
-    void encode_to(encoded_request_type& encoded, http_context&)
+    [[nodiscard]] std::error_code encode_to(encoded_request_type& encoded, http_context&)
     {
         std::string with_clause = force ? "WITH {\"force\": true}" : "";
 
@@ -60,11 +60,12 @@ struct analytics_link_connect_request {
         encoded.method = "POST";
         encoded.path = "/analytics/service";
         encoded.body = tao::json::to_string(body);
+        return {};
     }
 };
 
 analytics_link_connect_response
-make_response(std::error_code ec, analytics_link_connect_request& request, analytics_link_connect_request::encoded_response_type encoded)
+make_response(std::error_code ec, analytics_link_connect_request& request, analytics_link_connect_request::encoded_response_type&& encoded)
 {
     analytics_link_connect_response response{ request.client_context_id, ec };
     if (!ec) {

data/ext/couchbase/operations/analytics_link_disconnect.hxx

@@ -48,7 +48,7 @@ struct analytics_link_disconnect_request {
     std::string dataverse_name{ "Default" };
     std::string link_name;
 
-    void encode_to(encoded_request_type& encoded, http_context&)
+    [[nodiscard]] std::error_code encode_to(encoded_request_type& encoded, http_context&)
     {
         tao::json::value body{
             { "statement", fmt::format("DISCONNECT LINK `{}`.`{}`", dataverse_name, link_name) },
@@ -57,13 +57,14 @@ struct analytics_link_disconnect_request {
         encoded.method = "POST";
         encoded.path = "/analytics/service";
         encoded.body = tao::json::to_string(body);
+        return {};
     }
 };
 
 analytics_link_disconnect_response
 make_response(std::error_code ec,
               analytics_link_disconnect_request& request,
-              analytics_link_disconnect_request::encoded_response_type encoded)
+              analytics_link_disconnect_request::encoded_response_type&& encoded)
 {
     analytics_link_disconnect_response response{ request.client_context_id, ec };
     if (!ec) {

data/ext/couchbase/operations/bucket_create.hxx

@@ -43,7 +43,7 @@ struct bucket_create_request {
     std::chrono::milliseconds timeout{ timeout_defaults::management_timeout };
     std::string client_context_id{ uuid::to_string(uuid::random()) };
 
-    void encode_to(encoded_request_type& encoded, http_context&)
+    [[nodiscard]] std::error_code encode_to(encoded_request_type& encoded, http_context&)
     {
         encoded.method = "POST";
         encoded.path = fmt::format("/pools/default/buckets");
@@ -107,11 +107,12 @@ struct bucket_create_request {
             case bucket_settings::conflict_resolution_type::unknown:
                 break;
         }
+        return {};
     }
 };
 
 bucket_create_response
-make_response(std::error_code ec, bucket_create_request& request, bucket_create_request::encoded_response_type encoded)
+make_response(std::error_code ec, bucket_create_request& request, bucket_create_request::encoded_response_type&& encoded)
 {
     bucket_create_response response{ request.client_context_id, ec };
     if (!ec) {

data/ext/couchbase/operations/bucket_drop.hxx

@@ -38,15 +38,16 @@ struct bucket_drop_request {
     std::chrono::milliseconds timeout{ timeout_defaults::management_timeout };
     std::string client_context_id{ uuid::to_string(uuid::random()) };
 
-    void encode_to(encoded_request_type& encoded, http_context&)
+    [[nodiscard]] std::error_code encode_to(encoded_request_type& encoded, http_context&)
     {
         encoded.method = "DELETE";
         encoded.path = fmt::format("/pools/default/buckets/{}", name);
+        return {};
     }
 };
 
 bucket_drop_response
-make_response(std::error_code ec, bucket_drop_request& request, bucket_drop_request::encoded_response_type encoded)
+make_response(std::error_code ec, bucket_drop_request& request, bucket_drop_request::encoded_response_type&& encoded)
 {
     bucket_drop_response response{ request.client_context_id, ec };
     if (!ec) {

data/ext/couchbase/operations/bucket_flush.hxx

@@ -38,15 +38,16 @@ struct bucket_flush_request {
     std::chrono::milliseconds timeout{ timeout_defaults::management_timeout };
     std::string client_context_id{ uuid::to_string(uuid::random()) };
 
-    void encode_to(encoded_request_type& encoded, http_context&)
+    [[nodiscard]] std::error_code encode_to(encoded_request_type& encoded, http_context&)
     {
         encoded.method = "POST";
         encoded.path = fmt::format("/pools/default/buckets/{}/controller/doFlush", name);
+        return {};
     }
 };
 
 bucket_flush_response
-make_response(std::error_code ec, bucket_flush_request& request, bucket_flush_request::encoded_response_type encoded)
+make_response(std::error_code ec, bucket_flush_request& request, bucket_flush_request::encoded_response_type&& encoded)
 {
     bucket_flush_response response{ request.client_context_id, ec };
     if (!ec) {

data/ext/couchbase/operations/bucket_get.hxx

@@ -42,15 +42,16 @@ struct bucket_get_request {
     std::chrono::milliseconds timeout{ timeout_defaults::management_timeout };
     std::string client_context_id{ uuid::to_string(uuid::random()) };
 
-    void encode_to(encoded_request_type& encoded, http_context&)
+    [[nodiscard]] std::error_code encode_to(encoded_request_type& encoded, http_context&)
     {
         encoded.method = "GET";
         encoded.path = fmt::format("/pools/default/buckets/{}", name);
+        return {};
     }
 };
 
 bucket_get_response
-make_response(std::error_code ec, bucket_get_request& request, bucket_get_request::encoded_response_type encoded)
+make_response(std::error_code ec, bucket_get_request& request, bucket_get_request::encoded_response_type&& encoded)
 {
     bucket_get_response response{ request.client_context_id, ec };
     if (!ec) {

data/ext/couchbase/operations/bucket_get_all.hxx

@@ -40,15 +40,16 @@ struct bucket_get_all_request {
     std::chrono::milliseconds timeout{ timeout_defaults::management_timeout };
     std::string client_context_id{ uuid::to_string(uuid::random()) };
 
-    void encode_to(encoded_request_type& encoded, http_context&)
+    [[nodiscard]] std::error_code encode_to(encoded_request_type& encoded, http_context&)
     {
         encoded.method = "GET";
         encoded.path = "/pools/default/buckets";
+        return {};
     }
 };
 
 bucket_get_all_response
-make_response(std::error_code ec, bucket_get_all_request& request, bucket_get_all_request::encoded_response_type encoded)
+make_response(std::error_code ec, bucket_get_all_request& request, bucket_get_all_request::encoded_response_type&& encoded)
 {
     bucket_get_all_response response{ request.client_context_id, ec };
     if (!ec) {

data/ext/couchbase/operations/bucket_update.hxx

@@ -44,7 +44,7 @@ struct bucket_update_request {
 
     bucket_settings bucket{};
 
-    void encode_to(encoded_request_type& encoded, http_context&)
+    [[nodiscard]] std::error_code encode_to(encoded_request_type& encoded, http_context&)
     {
         encoded.method = "POST";
         encoded.path = fmt::format("/pools/default/buckets/{}", bucket.name);
@@ -84,11 +84,12 @@ struct bucket_update_request {
             case bucket_settings::compression_mode::unknown:
                 break;
         }
+        return {};
     }
 };
 
 bucket_update_response
-make_response(std::error_code ec, bucket_update_request& request, bucket_update_request::encoded_response_type encoded)
+make_response(std::error_code ec, bucket_update_request& request, bucket_update_request::encoded_response_type&& encoded)
 {
     bucket_update_response response{ request.client_context_id, ec };
     if (!ec) {

data/ext/couchbase/operations/cluster_developer_preview_enable.hxx

@@ -39,17 +39,18 @@ struct cluster_developer_preview_enable_request {
     std::chrono::milliseconds timeout{ timeout_defaults::management_timeout };
     std::string client_context_id{ uuid::to_string(uuid::random()) };
 
-    void encode_to(encoded_request_type& encoded, http_context&)
+    [[nodiscard]] std::error_code encode_to(encoded_request_type& encoded, http_context&)
     {
         encoded.method = "POST";
         encoded.headers["content-type"] = "application/x-www-form-urlencoded";
         encoded.path = "/settings/developerPreview";
         encoded.body = "enabled=true";
+        return {};
     }
 };
 
 cluster_developer_preview_enable_response
-make_response(std::error_code ec, cluster_developer_preview_enable_request& request, scope_get_all_request::encoded_response_type encoded)
+make_response(std::error_code ec, cluster_developer_preview_enable_request& request, scope_get_all_request::encoded_response_type&& encoded)
 {
     cluster_developer_preview_enable_response response{ request.client_context_id, ec };
     if (!ec) {

data/ext/couchbase/operations/collection_create.hxx

@@ -46,7 +46,7 @@ struct collection_create_request {
     std::chrono::milliseconds timeout{ timeout_defaults::management_timeout };
     std::string client_context_id{ uuid::to_string(uuid::random()) };
 
-    void encode_to(encoded_request_type& encoded, http_context&)
+    [[nodiscard]] std::error_code encode_to(encoded_request_type& encoded, http_context&)
     {
         encoded.method = "POST";
         encoded.path = fmt::format("/pools/default/buckets/{}/collections/{}", bucket_name, scope_name);
@@ -55,11 +55,12 @@ struct collection_create_request {
         if (max_expiry > 0) {
             encoded.body.append(fmt::format("&maxTTL={}", max_expiry));
         }
+        return {};
     }
 };
 
 collection_create_response
-make_response(std::error_code ec, collection_create_request& request, collection_create_request::encoded_response_type encoded)
+make_response(std::error_code ec, collection_create_request& request, collection_create_request::encoded_response_type&& encoded)
 {
     collection_create_response response{ request.client_context_id, ec };
     if (!ec) {