couchbase 3.0.2 → 3.0.3

data/ext/couchbase/operations/document_append.hxx

@@ -25,9 +25,7 @@ namespace couchbase::operations
 {
 
 struct append_response {
-    document_id id;
-    std::uint32_t opaque;
-    std::error_code ec{};
+    error_context::key_value ctx;
     std::uint64_t cas{};
     mutation_token token{};
 };
@@ -59,17 +57,14 @@ struct append_request {
 };
 
 append_response
-make_response(std::error_code ec, append_request& request, append_request::encoded_response_type&& encoded)
+make_response(error_context::key_value&& ctx, append_request& request, append_request::encoded_response_type&& encoded)
 {
-    append_response response{ request.id, encoded.opaque(), ec };
-    if (ec && response.opaque == 0) {
-        response.opaque = request.opaque;
-    }
-    if (!ec) {
+    append_response response{ ctx };
+    if (!response.ctx.ec) {
         response.cas = encoded.cas();
         response.token = encoded.body().token();
         response.token.partition_id = request.partition;
-        response.token.bucket_name = response.id.bucket;
+        response.token.bucket_name = response.ctx.id.bucket;
     }
     return response;
 }

data/ext/couchbase/operations/document_decrement.hxx

@@ -25,9 +25,7 @@ namespace couchbase::operations
 {
 
 struct decrement_response {
-    document_id id;
-    std::uint32_t opaque;
-    std::error_code ec{};
+    error_context::key_value ctx;
     std::uint64_t content{};
     std::uint64_t cas{};
     mutation_token token{};
@@ -69,18 +67,15 @@ struct decrement_request {
 };
 
 decrement_response
-make_response(std::error_code ec, decrement_request& request, decrement_request::encoded_response_type&& encoded)
+make_response(error_context::key_value&& ctx, decrement_request& request, decrement_request::encoded_response_type&& encoded)
 {
-    decrement_response response{ request.id, encoded.opaque(), ec };
-    if (ec && response.opaque == 0) {
-        response.opaque = request.opaque;
-    }
-    if (!ec) {
+    decrement_response response{ ctx };
+    if (!ctx.ec) {
         response.cas = encoded.cas();
         response.content = encoded.body().content();
         response.token = encoded.body().token();
         response.token.partition_id = request.partition;
-        response.token.bucket_name = response.id.bucket;
+        response.token.bucket_name = response.ctx.id.bucket;
     }
     return response;
 }

data/ext/couchbase/operations/document_exists.hxx

@@ -27,9 +27,7 @@ namespace couchbase::operations
 struct exists_response {
     enum class observe_status { invalid, found, not_found, persisted, logically_deleted };
 
-    document_id id;
-    std::uint32_t opaque;
-    std::error_code ec{};
+    error_context::key_value ctx;
     std::uint16_t partition_id{};
     std::uint64_t cas{};
     observe_status status{ observe_status::invalid };
@@ -54,10 +52,10 @@ struct exists_request {
 };
 
 exists_response
-make_response(std::error_code ec, exists_request& request, exists_request::encoded_response_type&& encoded)
+make_response(error_context::key_value&& ctx, exists_request& request, exists_request::encoded_response_type&& encoded)
 {
-    exists_response response{ request.id, encoded.opaque(), ec, request.partition };
-    if (!ec) {
+    exists_response response{ ctx, request.partition };
+    if (!ctx.ec) {
         response.cas = encoded.body().cas();
         response.partition_id = encoded.body().partition_id();
         switch (encoded.body().status()) {

data/ext/couchbase/operations/document_get.hxx

@@ -18,16 +18,15 @@
 #pragma once
 
 #include <document_id.hxx>
-#include <protocol/cmd_get.hxx>
+#include <error_context/key_value.hxx>
 #include <io/retry_context.hxx>
+#include <protocol/cmd_get.hxx>
 
 namespace couchbase::operations
 {
 
 struct get_response {
-    document_id id;
-    std::uint32_t opaque;
-    std::error_code ec{};
+    error_context::key_value ctx;
     std::string value{};
     std::uint64_t cas{};
     std::uint32_t flags{};
@@ -53,13 +52,10 @@ struct get_request {
 };
 
 get_response
-make_response(std::error_code ec, get_request& request, get_request::encoded_response_type&& encoded)
+make_response(error_context::key_value&& ctx, get_request&, get_request::encoded_response_type&& encoded)
 {
-    get_response response{ request.id, encoded.opaque(), ec };
-    if (ec && response.opaque == 0) {
-        response.opaque = request.opaque;
-    }
-    if (!ec) {
+    get_response response{ ctx };
+    if (!response.ctx.ec) {
         response.value = std::move(encoded.body().value());
         response.cas = encoded.cas();
         response.flags = encoded.body().flags();

data/ext/couchbase/operations/document_get_and_lock.hxx

@@ -25,9 +25,7 @@ namespace couchbase::operations
 {
 
 struct get_and_lock_response {
-    document_id id;
-    std::uint32_t opaque;
-    std::error_code ec{};
+    error_context::key_value ctx;
     std::string value{};
     std::uint64_t cas{};
     std::uint32_t flags{};
@@ -55,13 +53,10 @@ struct get_and_lock_request {
 };
 
 get_and_lock_response
-make_response(std::error_code ec, get_and_lock_request& request, get_and_lock_request::encoded_response_type&& encoded)
+make_response(error_context::key_value&& ctx, get_and_lock_request&, get_and_lock_request::encoded_response_type&& encoded)
 {
-    get_and_lock_response response{ request.id, encoded.opaque(), ec };
-    if (ec && response.opaque == 0) {
-        response.opaque = request.opaque;
-    }
-    if (!ec) {
+    get_and_lock_response response{ ctx };
+    if (!response.ctx.ec) {
         response.value = std::move(encoded.body().value());
         response.cas = encoded.cas();
         response.flags = encoded.body().flags();

data/ext/couchbase/operations/document_get_and_touch.hxx

@@ -25,9 +25,7 @@ namespace couchbase::operations
 {
 
 struct get_and_touch_response {
-    document_id id;
-    std::uint32_t opaque;
-    std::error_code ec{};
+    error_context::key_value ctx;
     std::string value{};
     std::uint64_t cas{};
     std::uint32_t flags{};
@@ -55,13 +53,10 @@ struct get_and_touch_request {
 };
 
 get_and_touch_response
-make_response(std::error_code ec, get_and_touch_request& request, get_and_touch_request::encoded_response_type&& encoded)
+make_response(error_context::key_value&& ctx, get_and_touch_request&, get_and_touch_request::encoded_response_type&& encoded)
 {
-    get_and_touch_response response{ request.id, encoded.opaque(), ec };
-    if (ec && response.opaque == 0) {
-        response.opaque = request.opaque;
-    }
-    if (!ec) {
+    get_and_touch_response response{ ctx };
+    if (!response.ctx.ec) {
         response.value = std::move(encoded.body().value());
         response.cas = encoded.cas();
         response.flags = encoded.body().flags();

data/ext/couchbase/operations/document_get_projected.hxx

@@ -1,6 +1,6 @@
 /* -*- Mode: C++; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */
 /*
- *     Copyright 2020 Couchbase, Inc.
+ *     Copyright 2020-2021 Couchbase, Inc.
  *
  *   Licensed under the Apache License, Version 2.0 (the "License");
  *   you may not use this file except in compliance with the License.
@@ -25,9 +25,7 @@ namespace couchbase::operations
 {
 
 struct get_projected_response {
-    document_id id;
-    std::uint32_t opaque;
-    std::error_code ec{};
+    error_context::key_value ctx;
     std::string value{};
     std::uint64_t cas{};
     std::uint32_t flags{};
@@ -198,13 +196,10 @@ subdoc_apply_projection(tao::json::value& root, const std::string& path, tao::js
 } // namespace priv
 
 get_projected_response
-make_response(std::error_code ec, get_projected_request& request, get_projected_request::encoded_response_type&& encoded)
+make_response(error_context::key_value&& ctx, get_projected_request& request, get_projected_request::encoded_response_type&& encoded)
 {
-    get_projected_response response{ request.id, encoded.opaque(), ec };
-    if (ec && response.opaque == 0) {
-        response.opaque = request.opaque;
-    }
-    if (!ec) {
+    get_projected_response response{ ctx };
+    if (!response.ctx.ec) {
         response.cas = encoded.cas();
         if (request.with_expiry && !encoded.body().fields()[0].value.empty()) {
             response.expiry = gsl::narrow_cast<std::uint32_t>(std::stoul(encoded.body().fields()[0].value));
@@ -215,14 +210,20 @@ make_response(std::error_code ec, get_projected_request& request, get_projected_
                 // 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_expiry ? 1 : 0].value);
+                tao::json::value full_doc{};
+                try {
+                    full_doc = tao::json::from_string(encoded.body().fields()[request.with_expiry ? 1 : 0].value);
+                } catch (tao::json::pegtl::parse_error& e) {
+                    response.ctx.ec = std::make_error_code(error::common_errc::parsing_failure);
+                    return response;
+                }
                 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);
+                        response.ctx.ec = std::make_error_code(error::key_value_errc::path_not_found);
                         return response;
                     }
                 }
@@ -234,10 +235,16 @@ make_response(std::error_code ec, get_projected_request& request, get_projected_
             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);
+                    tao::json::value value_to_apply{};
+                    try {
+                        value_to_apply = tao::json::from_string(field.value);
+                    } catch (tao::json::pegtl::parse_error& e) {
+                        response.ctx.ec = std::make_error_code(error::common_errc::parsing_failure);
+                        return response;
+                    }
                     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);
+                    response.ctx.ec = std::make_error_code(error::key_value_errc::path_not_found);
                     return response;
                 }
             }

data/ext/couchbase/operations/document_increment.hxx

@@ -27,9 +27,7 @@ namespace couchbase::operations
 {
 
 struct increment_response {
-    document_id id;
-    std::uint32_t opaque;
-    std::error_code ec{};
+    error_context::key_value ctx;
     std::uint64_t content{};
     std::uint64_t cas{};
     mutation_token token{};
@@ -71,18 +69,15 @@ struct increment_request {
 };
 
 increment_response
-make_response(std::error_code ec, increment_request& request, increment_request::encoded_response_type&& encoded)
+make_response(error_context::key_value&& ctx, increment_request& request, increment_request::encoded_response_type&& encoded)
 {
-    increment_response response{ request.id, encoded.opaque(), ec };
-    if (ec && response.opaque == 0) {
-        response.opaque = request.opaque;
-    }
-    if (!ec) {
+    increment_response response{ ctx };
+    if (!response.ctx.ec) {
         response.cas = encoded.cas();
         response.content = encoded.body().content();
         response.token = encoded.body().token();
         response.token.partition_id = request.partition;
-        response.token.bucket_name = response.id.bucket;
+        response.token.bucket_name = response.ctx.id.bucket;
     }
     return response;
 }

data/ext/couchbase/operations/document_insert.hxx

@@ -26,9 +26,7 @@ namespace couchbase::operations
 {
 
 struct insert_response {
-    document_id id;
-    std::uint32_t opaque;
-    std::error_code ec{};
+    error_context::key_value ctx;
     std::uint64_t cas{};
     mutation_token token{};
 };
@@ -64,17 +62,14 @@ struct insert_request {
 };
 
 insert_response
-make_response(std::error_code ec, insert_request& request, insert_request::encoded_response_type&& encoded)
+make_response(error_context::key_value&& ctx, insert_request& request, insert_request::encoded_response_type&& encoded)
 {
-    insert_response response{ request.id, encoded.opaque(), ec };
-    if (ec && response.opaque == 0) {
-        response.opaque = request.opaque;
-    }
-    if (!ec) {
+    insert_response response{ ctx };
+    if (!response.ctx.ec) {
         response.cas = encoded.cas();
         response.token = encoded.body().token();
         response.token.partition_id = request.partition;
-        response.token.bucket_name = response.id.bucket;
+        response.token.bucket_name = response.ctx.id.bucket;
     }
     return response;
 }

data/ext/couchbase/operations/document_lookup_in.hxx

@@ -34,9 +34,7 @@ struct lookup_in_response {
         std::string value;
         std::size_t original_index;
     };
-    document_id id;
-    std::uint32_t opaque;
-    std::error_code ec{};
+    error_context::key_value ctx;
     std::uint64_t cas{};
     std::vector<field> fields{};
     bool deleted{ false };
@@ -78,17 +76,14 @@ struct lookup_in_request {
 };
 
 lookup_in_response
-make_response(std::error_code ec, lookup_in_request& request, lookup_in_request::encoded_response_type&& encoded)
+make_response(error_context::key_value&& ctx, lookup_in_request& request, lookup_in_request::encoded_response_type&& encoded)
 {
-    lookup_in_response response{ request.id, encoded.opaque(), ec };
-    if (ec && response.opaque == 0) {
-        response.opaque = request.opaque;
-    }
+    lookup_in_response response{ ctx };
     if (encoded.status() == protocol::status::subdoc_success_deleted ||
         encoded.status() == protocol::status::subdoc_multi_path_failure_deleted) {
         response.deleted = true;
     }
-    if (!ec) {
+    if (!ctx.ec) {
         response.cas = encoded.cas();
         response.fields.resize(request.specs.entries.size());
         for (size_t i = 0; i < request.specs.entries.size(); ++i) {

data/ext/couchbase/operations/document_mutate_in.hxx

@@ -43,9 +43,7 @@ struct mutate_in_response {
         std::string value;
         std::size_t original_index;
     };
-    document_id id;
-    std::uint32_t opaque;
-    std::error_code ec{};
+    error_context::key_value ctx;
     std::uint64_t cas{};
     mutation_token token{};
     std::vector<field> fields{};
@@ -109,21 +107,18 @@ struct mutate_in_request {
 };
 
 mutate_in_response
-make_response(std::error_code ec, mutate_in_request& request, mutate_in_request::encoded_response_type&& encoded)
+make_response(error_context::key_value&& ctx, mutate_in_request& request, mutate_in_request::encoded_response_type&& encoded)
 {
-    mutate_in_response response{ request.id, encoded.opaque(), ec };
-    if (ec && response.opaque == 0) {
-        response.opaque = request.opaque;
-    }
+    mutate_in_response response{ ctx };
     if (encoded.status() == protocol::status::subdoc_success_deleted ||
         encoded.status() == protocol::status::subdoc_multi_path_failure_deleted) {
         response.deleted = true;
     }
-    if (!ec) {
+    if (!response.ctx.ec) {
         response.cas = encoded.cas();
         response.token = encoded.body().token();
         response.token.partition_id = request.partition;
-        response.token.bucket_name = response.id.bucket;
+        response.token.bucket_name = response.ctx.id.bucket;
         response.fields.resize(request.specs.entries.size());
         for (size_t i = 0; i < request.specs.entries.size(); ++i) {
             auto& req_entry = request.specs.entries[i];
@@ -147,8 +142,8 @@ make_response(std::error_code ec, mutate_in_request& request, mutate_in_request:
                       return lhs.original_index < rhs.original_index;
                   });
     } else if (request.store_semantics == protocol::mutate_in_request_body::store_semantics_type::insert &&
-               ec == std::make_error_code(error::common_errc::cas_mismatch)) {
-        response.ec = std::make_error_code(error::key_value_errc::document_exists);
+               response.ctx.ec == std::make_error_code(error::common_errc::cas_mismatch)) {
+        response.ctx.ec = std::make_error_code(error::key_value_errc::document_exists);
     }
     return response;
 }

data/ext/couchbase/operations/document_prepend.hxx

@@ -25,9 +25,7 @@ namespace couchbase::operations
 {
 
 struct prepend_response {
-    document_id id;
-    std::uint32_t opaque;
-    std::error_code ec{};
+    error_context::key_value ctx;
     std::uint64_t cas{};
     mutation_token token{};
 };
@@ -59,17 +57,14 @@ struct prepend_request {
 };
 
 prepend_response
-make_response(std::error_code ec, prepend_request& request, prepend_request::encoded_response_type&& encoded)
+make_response(error_context::key_value&& ctx, prepend_request& request, prepend_request::encoded_response_type&& encoded)
 {
-    prepend_response response{ request.id, encoded.opaque(), ec };
-    if (ec && response.opaque == 0) {
-        response.opaque = request.opaque;
-    }
-    if (!ec) {
+    prepend_response response{ ctx };
+    if (!response.ctx.ec) {
         response.cas = encoded.cas();
         response.token = encoded.body().token();
         response.token.partition_id = request.partition;
-        response.token.bucket_name = response.id.bucket;
+        response.token.bucket_name = response.ctx.id.bucket;
     }
     return response;
 }

data/ext/couchbase/operations/document_query.hxx

@@ -1,6 +1,6 @@
 /* -*- Mode: C++; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */
 /*
- *     Copyright 2020 Couchbase, Inc.
+ *     Copyright 2020-2021 Couchbase, Inc.
  *
  *   Licensed under the Apache License, Version 2.0 (the "License");
  *   you may not use this file except in compliance with the License.
@@ -26,12 +26,13 @@
 #include <version.hxx>
 
 #include <errors.hxx>
+#include <io/http_context.hxx>
+#include <io/http_message.hxx>
 #include <mutation_token.hxx>
-#include <service_type.hxx>
 #include <platform/uuid.h>
+#include <service_type.hxx>
 #include <timeout_defaults.hxx>
-#include <io/http_message.hxx>
-#include <io/http_context.hxx>
+#include <error_context/query.hxx>
 
 namespace couchbase::operations
 {
@@ -48,8 +49,8 @@ struct query_response_payload {
     };
 
     struct query_problem {
-        std::uint64_t code;
-        std::string message;
+        std::uint64_t code{};
+        std::string message{};
     };
 
     struct query_meta_data {
@@ -149,8 +150,7 @@ struct traits<couchbase::operations::query_response_payload> {
 namespace couchbase::operations
 {
 struct query_response {
-    std::string client_context_id;
-    std::error_code ec;
+    error_context::query ctx;
     query_response_payload payload{};
 };
 
@@ -158,6 +158,7 @@ struct query_request {
     using response_type = query_response;
     using encoded_request_type = io::http_request;
     using encoded_response_type = io::http_response;
+    using error_context_type = error_context::query;
 
     enum class scan_consistency_type { not_bounded, request_plus };
 
@@ -196,6 +197,8 @@ struct query_request {
     std::optional<http_context> ctx_{};
     bool extract_encoded_plan_{ false };
 
+    std::string body_str{};
+
     [[nodiscard]] std::error_code encode_to(encoded_request_type& encoded, http_context& context)
     {
         ctx_.emplace(context);
@@ -298,7 +301,7 @@ struct query_request {
             body["query_context"] = scope_qualifier;
         } else if (scope_name) {
             if (bucket_name) {
-                body["query_context"] = fmt::format("`{}`.{}", *bucket_name, *scope_name);
+                body["query_context"] = fmt::format("default:`{}`.`{}`", *bucket_name, *scope_name);
             }
         }
         for (auto& param : raw) {
@@ -309,7 +312,8 @@ struct query_request {
         encoded.headers["content-type"] = "application/json";
         encoded.method = "POST";
         encoded.path = "/query/service";
-        encoded.body = tao::json::to_string(body);
+        body_str = tao::json::to_string(body);
+        encoded.body = body_str;
 
         tao::json::value stmt = body["statement"];
         tao::json::value prep = body["prepared"];
@@ -329,11 +333,18 @@ struct query_request {
 };
 
 query_response
-make_response(std::error_code ec, query_request& request, query_request::encoded_response_type&& encoded)
+make_response(error_context::query&& ctx, query_request& request, query_request::encoded_response_type&& encoded)
 {
-    query_response response{ request.client_context_id, ec };
-    if (!ec) {
-        response.payload = tao::json::from_string(encoded.body).as<query_response_payload>();
+    query_response response{ ctx };
+    response.ctx.statement = request.statement;
+    response.ctx.parameters = request.body_str;
+    if (!response.ctx.ec) {
+        try {
+            response.payload = tao::json::from_string(encoded.body).as<query_response_payload>();
+        } catch (tao::json::pegtl::parse_error& e) {
+            response.ctx.ec = std::make_error_code(error::common_errc::parsing_failure);
+            return response;
+        }
         Expects(response.payload.meta_data.client_context_id.empty() ||
                 response.payload.meta_data.client_context_id == request.client_context_id);
         if (response.payload.meta_data.status == "success") {
@@ -342,17 +353,23 @@ make_response(std::error_code ec, query_request& request, query_request::encoded
             } else if (request.extract_encoded_plan_) {
                 request.extract_encoded_plan_ = false;
                 if (response.payload.rows.size() == 1) {
-                    auto row = tao::json::from_string(response.payload.rows[0]);
-                    auto plan = row.find("encoded_plan");
-                    auto name = row.find("name");
+                    tao::json::value row{};
+                    try {
+                        row = tao::json::from_string(response.payload.rows[0]);
+                    } catch (tao::json::pegtl::parse_error& e) {
+                        response.ctx.ec = std::make_error_code(error::common_errc::parsing_failure);
+                        return response;
+                    }
+                    auto* plan = row.find("encoded_plan");
+                    auto* name = row.find("name");
                     if (plan != nullptr && name != nullptr) {
                         request.ctx_->cache.put(request.statement, name->get_string(), plan->get_string());
                         throw couchbase::priv::retry_http_request{};
-                    } else {
-                        response.ec = std::make_error_code(error::query_errc::prepared_statement_failure);
                     }
+                    response.ctx.ec = std::make_error_code(error::query_errc::prepared_statement_failure);
+
                 } else {
-                    response.ec = std::make_error_code(error::query_errc::prepared_statement_failure);
+                    response.ctx.ec = std::make_error_code(error::query_errc::prepared_statement_failure);
                 }
             }
         } else {
@@ -399,21 +416,21 @@ make_response(std::error_code ec, query_request& request, query_request::encoded
                 }
             }
             if (syntax_error) {
-                response.ec = std::make_error_code(error::common_errc::parsing_failure);
+                response.ctx.ec = std::make_error_code(error::common_errc::parsing_failure);
             } else if (invalid_argument) {
-                response.ec = std::make_error_code(error::common_errc::invalid_argument);
+                response.ctx.ec = std::make_error_code(error::common_errc::invalid_argument);
             } else if (server_timeout) {
-                response.ec = std::make_error_code(error::common_errc::unambiguous_timeout);
+                response.ctx.ec = std::make_error_code(error::common_errc::unambiguous_timeout);
             } else if (prepared_statement_failure) {
-                response.ec = std::make_error_code(error::query_errc::prepared_statement_failure);
+                response.ctx.ec = std::make_error_code(error::query_errc::prepared_statement_failure);
             } else if (index_failure) {
-                response.ec = std::make_error_code(error::query_errc::index_failure);
+                response.ctx.ec = std::make_error_code(error::query_errc::index_failure);
             } else if (planning_failure) {
-                response.ec = std::make_error_code(error::query_errc::planning_failure);
+                response.ctx.ec = std::make_error_code(error::query_errc::planning_failure);
             } else if (index_not_found) {
-                response.ec = std::make_error_code(error::common_errc::index_not_found);
+                response.ctx.ec = std::make_error_code(error::common_errc::index_not_found);
             } else {
-                response.ec = std::make_error_code(error::common_errc::internal_server_failure);
+                response.ctx.ec = std::make_error_code(error::common_errc::internal_server_failure);
             }
         }
     }