couchbase 3.1.1 → 3.2.0

data/ext/couchbase/operations/document_get_and_lock.hxx

@@ -42,7 +42,7 @@ struct get_and_lock_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);
@@ -53,9 +53,11 @@ struct get_and_lock_request {
 };
 
 get_and_lock_response
-make_response(error_context::key_value&& ctx, get_and_lock_request&, get_and_lock_request::encoded_response_type&& encoded)
+make_response(error_context::key_value&& ctx,
+              const get_and_lock_request& /* request */,
+              get_and_lock_request::encoded_response_type&& encoded)
 {
-    get_and_lock_response response{ ctx };
+    get_and_lock_response response{ std::move(ctx) };
     if (!response.ctx.ec) {
         response.value = std::move(encoded.body().value());
         response.cas = encoded.cas();

data/ext/couchbase/operations/document_get_and_touch.hxx

@@ -42,7 +42,7 @@ struct get_and_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);
@@ -53,9 +53,11 @@ struct get_and_touch_request {
 };
 
 get_and_touch_response
-make_response(error_context::key_value&& ctx, get_and_touch_request&, get_and_touch_request::encoded_response_type&& encoded)
+make_response(error_context::key_value&& ctx,
+              const get_and_touch_request& /* request */,
+              get_and_touch_request::encoded_response_type&& encoded)
 {
-    get_and_touch_response response{ ctx };
+    get_and_touch_response response{ std::move(ctx) };
     if (!response.ctx.ec) {
         response.value = std::move(encoded.body().value());
         response.cas = encoded.cas();

data/ext/couchbase/operations/document_get_projected.hxx

@@ -46,7 +46,7 @@ struct get_projected_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 */)
     {
         encoded.opaque(opaque);
         encoded.partition(partition);
@@ -111,8 +111,7 @@ subdoc_lookup(tao::json::value& root, const std::string& path)
                 break;
             }
             std::string key = path.substr(offset, idx - offset);
-            int array_index = std::stoi(key);
-            if (array_index == -1) {
+            if (int array_index = std::stoi(key); array_index == -1) {
                 cur = &cur->get_array().back();
             } else if (static_cast<std::size_t>(array_index) < cur->get_array().size()) {
                 cur = &cur->get_array().back();
@@ -196,9 +195,9 @@ subdoc_apply_projection(tao::json::value& root, const std::string& path, tao::js
 } // namespace priv
 
 get_projected_response
-make_response(error_context::key_value&& ctx, get_projected_request& request, get_projected_request::encoded_response_type&& encoded)
+make_response(error_context::key_value&& ctx, const get_projected_request& request, get_projected_request::encoded_response_type&& encoded)
 {
-    get_projected_response response{ ctx };
+    get_projected_response response{ std::move(ctx) };
     if (!response.ctx.ec) {
         response.cas = encoded.cas();
         if (request.with_expiry && !encoded.body().fields()[0].value.empty()) {
@@ -213,8 +212,8 @@ make_response(error_context::key_value&& ctx, get_projected_request& request, ge
                 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);
+                } catch (const tao::json::pegtl::parse_error& e) {
+                    response.ctx.ec = error::common_errc::parsing_failure;
                     return response;
                 }
                 tao::json::value new_doc;
@@ -223,7 +222,7 @@ make_response(error_context::key_value&& ctx, get_projected_request& request, ge
                     if (value_to_apply) {
                         priv::subdoc_apply_projection(new_doc, projection, *value_to_apply, request.preserve_array_indexes);
                     } else {
-                        response.ctx.ec = std::make_error_code(error::key_value_errc::path_not_found);
+                        response.ctx.ec = error::key_value_errc::path_not_found;
                         return response;
                     }
                 }
@@ -238,13 +237,13 @@ make_response(error_context::key_value&& ctx, get_projected_request& request, ge
                     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);
+                    } catch (const tao::json::pegtl::parse_error& e) {
+                        response.ctx.ec = error::common_errc::parsing_failure;
                         return response;
                     }
                     priv::subdoc_apply_projection(new_doc, projection, value_to_apply, request.preserve_array_indexes);
                 } else {
-                    response.ctx.ec = std::make_error_code(error::key_value_errc::path_not_found);
+                    response.ctx.ec = error::key_value_errc::path_not_found;
                     return response;
                 }
             }

data/ext/couchbase/operations/document_increment.hxx

@@ -49,7 +49,7 @@ struct increment_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);
@@ -73,9 +73,9 @@ struct increment_request {
 };
 
 increment_response
-make_response(error_context::key_value&& ctx, increment_request& request, increment_request::encoded_response_type&& encoded)
+make_response(error_context::key_value&& ctx, const increment_request& request, increment_request::encoded_response_type&& encoded)
 {
-    increment_response response{ ctx };
+    increment_response response{ std::move(ctx) };
     if (!response.ctx.ec) {
         response.cas = encoded.cas();
         response.content = encoded.body().content();

data/ext/couchbase/operations/document_insert.hxx

@@ -46,7 +46,7 @@ struct insert_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);
@@ -62,9 +62,9 @@ struct insert_request {
 };
 
 insert_response
-make_response(error_context::key_value&& ctx, insert_request& request, insert_request::encoded_response_type&& encoded)
+make_response(error_context::key_value&& ctx, const insert_request& request, insert_request::encoded_response_type&& encoded)
 {
-    insert_response response{ ctx };
+    insert_response response{ std::move(ctx) };
     if (!response.ctx.ec) {
         response.cas = encoded.cas();
         response.token = encoded.body().token();

data/ext/couchbase/operations/document_lookup_in.hxx

@@ -52,19 +52,15 @@ struct lookup_in_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 */)
     {
         for (std::size_t i = 0; i < specs.entries.size(); ++i) {
-            auto& entry = specs.entries[i];
-            entry.original_index = i;
+            specs.entries[i].original_index = i;
         }
-        std::stable_sort(specs.entries.begin(),
-                         specs.entries.end(),
-                         [](const protocol::lookup_in_request_body::lookup_in_specs::entry& lhs,
-                            const protocol::lookup_in_request_body::lookup_in_specs::entry& rhs) -> bool {
-                             return (lhs.flags & protocol::lookup_in_request_body::lookup_in_specs::path_flag_xattr) >
-                                    (rhs.flags & protocol::lookup_in_request_body::lookup_in_specs::path_flag_xattr);
-                         });
+        std::stable_sort(specs.entries.begin(), specs.entries.end(), [](const auto& lhs, const auto& rhs) {
+            return (lhs.flags & protocol::lookup_in_request_body::lookup_in_specs::path_flag_xattr) >
+                   (rhs.flags & protocol::lookup_in_request_body::lookup_in_specs::path_flag_xattr);
+        });
 
         encoded.opaque(opaque);
         encoded.partition(partition);
@@ -76,9 +72,9 @@ struct lookup_in_request {
 };
 
 lookup_in_response
-make_response(error_context::key_value&& ctx, lookup_in_request& request, lookup_in_request::encoded_response_type&& encoded)
+make_response(error_context::key_value&& ctx, const lookup_in_request& request, lookup_in_request::encoded_response_type&& encoded)
 {
-    lookup_in_response response{ ctx };
+    lookup_in_response response{ std::move(ctx) };
     if (encoded.status() == protocol::status::subdoc_success_deleted ||
         encoded.status() == protocol::status::subdoc_multi_path_failure_deleted) {
         response.deleted = true;
@@ -89,7 +85,7 @@ make_response(error_context::key_value&& ctx, lookup_in_request& request, lookup
         for (size_t i = 0; i < request.specs.entries.size(); ++i) {
             auto& req_entry = request.specs.entries[i];
             response.fields[i].original_index = req_entry.original_index;
-            response.fields[i].opcode = static_cast<protocol::subdoc_opcode>(req_entry.opcode);
+            response.fields[i].opcode = protocol::subdoc_opcode(req_entry.opcode);
             response.fields[i].path = req_entry.path;
             response.fields[i].status = protocol::status::success;
         }
@@ -100,11 +96,9 @@ make_response(error_context::key_value&& ctx, lookup_in_request& request, lookup
               res_entry.status == protocol::status::success || res_entry.status == protocol::status::subdoc_success_deleted;
             response.fields[i].value = res_entry.value;
         }
-        std::sort(response.fields.begin(),
-                  response.fields.end(),
-                  [](const lookup_in_response::field& lhs, const lookup_in_response::field& rhs) -> bool {
-                      return lhs.original_index < rhs.original_index;
-                  });
+        std::sort(response.fields.begin(), response.fields.end(), [](const auto& lhs, const auto& rhs) {
+            return lhs.original_index < rhs.original_index;
+        });
     }
     return response;
 }

data/ext/couchbase/operations/document_mutate_in.hxx

@@ -75,19 +75,16 @@ struct mutate_in_request {
     [[nodiscard]] std::error_code encode_to(encoded_request_type& encoded, mcbp_context&& ctx)
     {
         if (create_as_deleted && !ctx.supports_feature(protocol::hello_feature::subdoc_create_as_deleted)) {
-            return std::make_error_code(error::common_errc::unsupported_operation);
+            return error::common_errc::unsupported_operation;
         }
         for (std::size_t i = 0; i < specs.entries.size(); ++i) {
             auto& entry = specs.entries[i];
             entry.original_index = i;
         }
-        std::stable_sort(specs.entries.begin(),
-                         specs.entries.end(),
-                         [](const protocol::mutate_in_request_body::mutate_in_specs::entry& lhs,
-                            const protocol::mutate_in_request_body::mutate_in_specs::entry& rhs) -> bool {
-                             return (lhs.flags & protocol::mutate_in_request_body::mutate_in_specs::path_flag_xattr) >
-                                    (rhs.flags & protocol::mutate_in_request_body::mutate_in_specs::path_flag_xattr);
-                         });
+        std::stable_sort(specs.entries.begin(), specs.entries.end(), [](const auto& lhs, const auto& rhs) {
+            return (lhs.flags & protocol::mutate_in_request_body::mutate_in_specs::path_flag_xattr) >
+                   (rhs.flags & protocol::mutate_in_request_body::mutate_in_specs::path_flag_xattr);
+        });
 
         encoded.opaque(opaque);
         encoded.partition(partition);
@@ -111,9 +108,9 @@ struct mutate_in_request {
 };
 
 mutate_in_response
-make_response(error_context::key_value&& ctx, mutate_in_request& request, mutate_in_request::encoded_response_type&& encoded)
+make_response(error_context::key_value&& ctx, const mutate_in_request& request, mutate_in_request::encoded_response_type&& encoded)
 {
-    mutate_in_response response{ ctx };
+    mutate_in_response response{ std::move(ctx) };
     if (encoded.status() == protocol::status::subdoc_success_deleted ||
         encoded.status() == protocol::status::subdoc_multi_path_failure_deleted) {
         response.deleted = true;
@@ -127,7 +124,7 @@ make_response(error_context::key_value&& ctx, mutate_in_request& request, mutate
         for (size_t i = 0; i < request.specs.entries.size(); ++i) {
             auto& req_entry = request.specs.entries[i];
             response.fields[i].original_index = req_entry.original_index;
-            response.fields[i].opcode = static_cast<protocol::subdoc_opcode>(req_entry.opcode);
+            response.fields[i].opcode = protocol::subdoc_opcode(req_entry.opcode);
             response.fields[i].path = req_entry.path;
             response.fields[i].status = protocol::status::success;
         }
@@ -140,14 +137,12 @@ make_response(error_context::key_value&& ctx, mutate_in_request& request, mutate
                 break;
             }
         }
-        std::sort(response.fields.begin(),
-                  response.fields.end(),
-                  [](const mutate_in_response::field& lhs, const mutate_in_response::field& rhs) -> bool {
-                      return lhs.original_index < rhs.original_index;
-                  });
+        std::sort(response.fields.begin(), response.fields.end(), [](const auto& lhs, const auto& rhs) {
+            return lhs.original_index < rhs.original_index;
+        });
     } else if (request.store_semantics == protocol::mutate_in_request_body::store_semantics_type::insert &&
-               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);
+               response.ctx.ec == error::common_errc::cas_mismatch) {
+        response.ctx.ec = error::key_value_errc::document_exists;
     }
     return response;
 }

data/ext/couchbase/operations/document_prepend.hxx

@@ -43,7 +43,7 @@ struct prepend_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 prepend_request {
 };
 
 prepend_response
-make_response(error_context::key_value&& ctx, prepend_request& request, prepend_request::encoded_response_type&& encoded)
+make_response(error_context::key_value&& ctx, const prepend_request& request, prepend_request::encoded_response_type&& encoded)
 {
-    prepend_response response{ ctx };
+    prepend_response response{ std::move(ctx) };
     if (!response.ctx.ec) {
         response.cas = encoded.cas();
         response.token = encoded.body().token();

data/ext/couchbase/operations/document_query.hxx

@@ -79,28 +79,22 @@ struct traits<couchbase::operations::query_response_payload> {
     {
         couchbase::operations::query_response_payload result;
         result.meta_data.request_id = v.at("requestID").get_string();
-        const auto i = v.find("clientContextID");
-        if (i != nullptr) {
+
+        if (const auto* i = v.find("clientContextID"); i != nullptr) {
             result.meta_data.client_context_id = i->get_string();
         }
         result.meta_data.status = v.at("status").get_string();
-        const auto s = v.find("signature");
-        if (s != nullptr) {
+        if (const auto* s = v.find("signature"); s != nullptr) {
             result.meta_data.signature = tao::json::to_string(*s);
         }
-        {
-            const auto c = v.find("prepared");
-            if (c != nullptr) {
-                result.prepared = c->get_string();
-            }
+        if (const auto* c = v.find("prepared"); c != nullptr) {
+            result.prepared = c->get_string();
         }
-        const auto p = v.find("profile");
-        if (p != nullptr) {
+        if (const auto* p = v.find("profile"); p != nullptr) {
             result.meta_data.profile = tao::json::to_string(*p);
         }
 
-        const auto m = v.find("metrics");
-        if (m != nullptr) {
+        if (const auto* m = v.find("metrics"); m != nullptr) {
             result.meta_data.metrics.result_count = m->at("resultCount").get_unsigned();
             result.meta_data.metrics.result_size = m->at("resultSize").get_unsigned();
             result.meta_data.metrics.elapsed_time = m->at("elapsedTime").get_string();
@@ -111,8 +105,7 @@ struct traits<couchbase::operations::query_response_payload> {
             result.meta_data.metrics.warning_count = m->template optional<std::uint64_t>("warningCount");
         }
 
-        const auto e = v.find("errors");
-        if (e != nullptr) {
+        if (const auto* e = v.find("errors"); e != nullptr) {
             std::vector<couchbase::operations::query_response_payload::query_problem> problems{};
             for (auto& err : e->get_array()) {
                 couchbase::operations::query_response_payload::query_problem problem;
@@ -123,8 +116,7 @@ struct traits<couchbase::operations::query_response_payload> {
             result.meta_data.errors.emplace(problems);
         }
 
-        const auto w = v.find("warnings");
-        if (w != nullptr) {
+        if (const auto* w = v.find("warnings"); w != nullptr) {
             std::vector<couchbase::operations::query_response_payload::query_problem> problems{};
             for (auto& warn : w->get_array()) {
                 couchbase::operations::query_response_payload::query_problem problem;
@@ -134,8 +126,8 @@ struct traits<couchbase::operations::query_response_payload> {
             }
             result.meta_data.warnings.emplace(problems);
         }
-        const auto r = v.find("results");
-        if (r != nullptr) {
+
+        if (const auto* r = v.find("results"); r != nullptr) {
             result.rows.reserve(result.meta_data.metrics.result_count);
             for (auto& row : r->get_array()) {
                 result.rows.emplace_back(tao::json::to_string(row));
@@ -225,13 +217,13 @@ struct query_request {
         body["timeout"] = fmt::format(
           "{}ms", ((timeout > std::chrono::milliseconds(5'000)) ? (timeout - std::chrono::milliseconds(500)) : timeout).count());
         if (positional_parameters.empty()) {
-            for (auto& param : named_parameters) {
-                Expects(param.first.empty() == false);
-                std::string key = param.first;
+            for (const auto& [name, value] : named_parameters) {
+                Expects(name.empty() == false);
+                std::string key = name;
                 if (key[0] != '$') {
                     key.insert(key.begin(), '$');
                 }
-                body[key] = param.second;
+                body[key] = value;
             }
         } else {
             body["args"] = positional_parameters;
@@ -304,8 +296,8 @@ struct query_request {
                 body["query_context"] = fmt::format("default:`{}`.`{}`", *bucket_name, *scope_name);
             }
         }
-        for (auto& param : raw) {
-            body[param.first] = param.second;
+        for (const auto& [name, value] : raw) {
+            body[name] = value;
         }
         encoded.type = type;
         encoded.headers["connection"] = "keep-alive";
@@ -335,14 +327,14 @@ struct query_request {
 query_response
 make_response(error_context::query&& ctx, query_request& request, query_request::encoded_response_type&& encoded)
 {
-    query_response response{ ctx };
+    query_response response{ std::move(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);
+        } catch (const tao::json::pegtl::parse_error&) {
+            response.ctx.ec = error::common_errc::parsing_failure;
             return response;
         }
         Expects(response.payload.meta_data.client_context_id.empty() ||
@@ -356,8 +348,8 @@ make_response(error_context::query&& ctx, query_request& request, query_request:
                     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);
+                    } catch (const tao::json::pegtl::parse_error&) {
+                        response.ctx.ec = error::common_errc::parsing_failure;
                         return response;
                     }
                     auto* plan = row.find("encoded_plan");
@@ -366,10 +358,10 @@ make_response(error_context::query&& ctx, query_request& request, query_request:
                         request.ctx_->cache.put(request.statement, name->get_string(), plan->get_string());
                         throw couchbase::priv::retry_http_request{};
                     }
-                    response.ctx.ec = std::make_error_code(error::query_errc::prepared_statement_failure);
+                    response.ctx.ec = error::query_errc::prepared_statement_failure;
 
                 } else {
-                    response.ctx.ec = std::make_error_code(error::query_errc::prepared_statement_failure);
+                    response.ctx.ec = error::query_errc::prepared_statement_failure;
                 }
             }
         } else {
@@ -381,6 +373,7 @@ make_response(error_context::query&& ctx, query_request& request, query_request:
             bool server_timeout = false;
             bool invalid_argument = false;
             bool cas_mismatch = false;
+            bool authentication_failure = false;
 
             if (response.payload.meta_data.errors) {
                 for (const auto& error : *response.payload.meta_data.errors) {
@@ -411,6 +404,9 @@ make_response(error_context::query&& ctx, query_request& request, query_request:
                         case 12016: /* IKey: "datastore.couchbase.index_not_found" */
                             index_not_found = true;
                             break;
+                        case 13014: /* IKey: "datastore.couchbase.insufficient_credentials" */
+                            authentication_failure = true;
+                            break;
                         default:
                             if ((error.code >= 12000 && error.code < 13000) || (error.code >= 14000 && error.code < 15000)) {
                                 index_failure = true;
@@ -422,23 +418,25 @@ make_response(error_context::query&& ctx, query_request& request, query_request:
                 }
             }
             if (syntax_error) {
-                response.ctx.ec = std::make_error_code(error::common_errc::parsing_failure);
+                response.ctx.ec = error::common_errc::parsing_failure;
             } else if (invalid_argument) {
-                response.ctx.ec = std::make_error_code(error::common_errc::invalid_argument);
+                response.ctx.ec = error::common_errc::invalid_argument;
             } else if (server_timeout) {
-                response.ctx.ec = std::make_error_code(error::common_errc::unambiguous_timeout);
+                response.ctx.ec = error::common_errc::unambiguous_timeout;
             } else if (prepared_statement_failure) {
-                response.ctx.ec = std::make_error_code(error::query_errc::prepared_statement_failure);
+                response.ctx.ec = error::query_errc::prepared_statement_failure;
             } else if (index_failure) {
-                response.ctx.ec = std::make_error_code(error::query_errc::index_failure);
+                response.ctx.ec = error::query_errc::index_failure;
             } else if (planning_failure) {
-                response.ctx.ec = std::make_error_code(error::query_errc::planning_failure);
+                response.ctx.ec = error::query_errc::planning_failure;
             } else if (index_not_found) {
-                response.ctx.ec = std::make_error_code(error::common_errc::index_not_found);
+                response.ctx.ec = error::common_errc::index_not_found;
             } else if (cas_mismatch) {
-                response.ctx.ec = std::make_error_code(error::common_errc::cas_mismatch);
+                response.ctx.ec = error::common_errc::cas_mismatch;
+            } else if (authentication_failure) {
+                response.ctx.ec = error::common_errc::authentication_failure;
             } else {
-                response.ctx.ec = std::make_error_code(error::common_errc::internal_server_failure);
+                response.ctx.ec = error::common_errc::internal_server_failure;
             }
         }
     }