couchbase 4.1.2 → 4.1.3

package/deps/couchbase-cxx-client/core/operations/management/collection_drop.hxx

@@ -0,0 +1,52 @@
+/* -*- Mode: C++; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */
+/*
+ *   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.
+ *   You may obtain a copy of the License at
+ *
+ *       http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *   Unless required by applicable law or agreed to in writing, software
+ *   distributed under the License is distributed on an "AS IS" BASIS,
+ *   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *   See the License for the specific language governing permissions and
+ *   limitations under the License.
+ */
+
+#pragma once
+
+#include "core/error_context/http.hxx"
+#include "core/io/http_context.hxx"
+#include "core/io/http_message.hxx"
+#include "core/platform/uuid.h"
+#include "core/timeout_defaults.hxx"
+
+namespace couchbase::core::operations::management
+{
+struct collection_drop_response {
+    error_context::http ctx;
+    std::uint64_t uid{ 0 };
+};
+
+struct collection_drop_request {
+    using response_type = collection_drop_response;
+    using encoded_request_type = io::http_request;
+    using encoded_response_type = io::http_response;
+    using error_context_type = error_context::http;
+
+    static const inline service_type type = service_type::management;
+
+    std::string bucket_name;
+    std::string scope_name;
+    std::string collection_name;
+
+    std::optional<std::string> client_context_id{};
+    std::optional<std::chrono::milliseconds> timeout{};
+
+    [[nodiscard]] std::error_code encode_to(encoded_request_type& encoded, http_context& context) const;
+
+    [[nodiscard]] collection_drop_response make_response(error_context::http&& ctx, const encoded_response_type& encoded) const;
+};
+} // namespace couchbase::core::operations::management

package/deps/couchbase-cxx-client/core/operations/management/collections.hxx

@@ -0,0 +1,25 @@
+/* -*- Mode: C++; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */
+/*
+ *   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.
+ *   You may obtain a copy of the License at
+ *
+ *       http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *   Unless required by applicable law or agreed to in writing, software
+ *   distributed under the License is distributed on an "AS IS" BASIS,
+ *   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *   See the License for the specific language governing permissions and
+ *   limitations under the License.
+ */
+
+#pragma once
+
+#include "collection_create.hxx"
+#include "collection_drop.hxx"
+#include "collections_manifest_get.hxx"
+#include "scope_create.hxx"
+#include "scope_drop.hxx"
+#include "scope_get_all.hxx"

package/deps/couchbase-cxx-client/core/operations/management/collections_manifest_get.cxx

@@ -0,0 +1,40 @@
+/* -*- Mode: C++; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */
+/*
+ *   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.
+ *   You may obtain a copy of the License at
+ *
+ *       http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *   Unless required by applicable law or agreed to in writing, software
+ *   distributed under the License is distributed on an "AS IS" BASIS,
+ *   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *   See the License for the specific language governing permissions and
+ *   limitations under the License.
+ */
+
+#include "collections_manifest_get.hxx"
+
+#include <couchbase/error_codes.hxx>
+
+namespace couchbase::core::operations::management
+{
+std::error_code
+collections_manifest_get_request::encode_to(encoded_request_type& encoded, mcbp_context&& /* context */) const
+{
+    encoded.opaque(opaque);
+    return {};
+}
+
+collections_manifest_get_response
+collections_manifest_get_request::make_response(key_value_error_context&& ctx, const encoded_response_type& encoded) const
+{
+    collections_manifest_get_response response{ std::move(ctx) };
+    if (!response.ctx.ec()) {
+        response.manifest = encoded.body().manifest();
+    }
+    return response;
+}
+} // namespace couchbase::core::operations::management

package/deps/couchbase-cxx-client/core/operations/management/collections_manifest_get.hxx

@@ -0,0 +1,53 @@
+/* -*- Mode: C++; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */
+/*
+ *   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.
+ *   You may obtain a copy of the License at
+ *
+ *       http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *   Unless required by applicable law or agreed to in writing, software
+ *   distributed under the License is distributed on an "AS IS" BASIS,
+ *   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *   See the License for the specific language governing permissions and
+ *   limitations under the License.
+ */
+
+#pragma once
+
+#include "core/document_id.hxx"
+#include "core/error_context/key_value.hxx"
+#include "core/io/mcbp_context.hxx"
+#include "core/io/retry_context.hxx"
+#include "core/protocol/client_request.hxx"
+#include "core/protocol/cmd_get_collections_manifest.hxx"
+#include "core/timeout_defaults.hxx"
+#include "core/topology/collections_manifest.hxx"
+
+namespace couchbase::core::operations::management
+{
+struct collections_manifest_get_response {
+    key_value_error_context ctx;
+    topology::collections_manifest manifest{};
+};
+
+struct collections_manifest_get_request {
+    using response_type = collections_manifest_get_response;
+    using encoded_request_type = protocol::client_request<protocol::get_collections_manifest_request_body>;
+    using encoded_response_type = protocol::client_response<protocol::get_collections_manifest_response_body>;
+
+    document_id id{};
+    std::uint16_t partition{};
+    std::uint32_t opaque{};
+
+    std::optional<std::chrono::milliseconds> timeout{};
+    io::retry_context<io::retry_strategy::best_effort> retries{ true };
+
+    [[nodiscard]] std::error_code encode_to(encoded_request_type& encoded, mcbp_context&& /* context */) const;
+
+    [[nodiscard]] collections_manifest_get_response make_response(key_value_error_context&& ctx,
+                                                                  const encoded_response_type& encoded) const;
+};
+} // namespace couchbase::core::operations::management

package/deps/couchbase-cxx-client/core/operations/management/error_utils.cxx

@@ -0,0 +1,267 @@
+/* -*- Mode: C++; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */
+/*
+ *   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.
+ *   You may obtain a copy of the License at
+ *
+ *       http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *   Unless required by applicable law or agreed to in writing, software
+ *   distributed under the License is distributed on an "AS IS" BASIS,
+ *   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *   See the License for the specific language governing permissions and
+ *   limitations under the License.
+ */
+
+#include "error_utils.hxx"
+#include "core/utils/json.hxx"
+
+namespace couchbase::core::operations::management
+{
+
+std::error_code
+extract_common_error_code(std::uint32_t status_code, const std::string& response_body)
+{
+    if (status_code == 429) {
+        if (response_body.find("Limit(s) exceeded") != std::string::npos) {
+            return errc::common::rate_limited;
+        }
+        if (response_body.find("Maximum number of collections has been reached for scope") != std::string::npos) {
+            return errc::common::quota_limited;
+        }
+    }
+    return errc::common::internal_server_failure;
+}
+
+std::optional<std::error_code>
+extract_common_query_error_code(std::uint64_t code, const std::string& message)
+{
+    switch (code) {
+        case 1191: /* ICode: E_SERVICE_USER_REQUEST_EXCEEDED, IKey: "service.requests.exceeded" */
+        case 1192: /* ICode: E_SERVICE_USER_REQUEST_RATE_EXCEEDED, IKey: "service.request.rate.exceeded" */
+        case 1193: /* ICode: E_SERVICE_USER_REQUEST_SIZE_EXCEEDED, IKey: "service.request.size.exceeded" */
+        case 1194: /* ICode: E_SERVICE_USER_RESULT_SIZE_EXCEEDED, IKey: "service.result.size.exceeded" */
+            return errc::common::rate_limited;
+
+        case 5000:
+            if (message.find("Limit for number of indexes that can be created per scope has been reached") != std::string::npos) {
+                return errc::common::quota_limited;
+            }
+            break;
+
+        default:
+            break;
+    }
+
+    return {};
+}
+
+std::pair<std::error_code, eventing_problem>
+extract_eventing_error_code(const tao::json::value& response)
+{
+    if (!response.is_object()) {
+        return {};
+    }
+    if (const auto& name = response.find("name"); name != nullptr && name->is_string()) {
+        eventing_problem problem{
+            response.at("code").get_unsigned(),
+            name->get_string(),
+            response.at("description").get_string(),
+        };
+        if (problem.name == "ERR_APP_NOT_FOUND_TS") {
+            return { errc::management::eventing_function_not_found, problem };
+        }
+        if (problem.name == "ERR_APP_NOT_DEPLOYED") {
+            if (const auto* runtime_info = response.find("runtime_info"); runtime_info != nullptr && runtime_info->is_object()) {
+                if (const auto* info = runtime_info->find("info");
+                    info != nullptr && info->is_string() && info->get_string().find("already in paused state") != std::string::npos) {
+                    return { errc::management::eventing_function_paused, problem };
+                }
+            }
+            return { errc::management::eventing_function_not_deployed, problem };
+        }
+        if (problem.name == "ERR_HANDLER_COMPILATION") {
+            return { errc::management::eventing_function_compilation_failure, problem };
+        }
+        if (problem.name == "ERR_COLLECTION_MISSING") {
+            return { errc::common::collection_not_found, problem };
+        }
+        if (problem.name == "ERR_SRC_MB_SAME") {
+            return { errc::management::eventing_function_identical_keyspace, problem };
+        }
+        if (problem.name == "ERR_APP_NOT_BOOTSTRAPPED") {
+            return { errc::management::eventing_function_not_bootstrapped, problem };
+        }
+        if (problem.name == "ERR_APP_NOT_UNDEPLOYED" || problem.name == "ERR_APP_ALREADY_DEPLOYED") {
+            return { errc::management::eventing_function_deployed, problem };
+        }
+        if (problem.name == "ERR_APP_PAUSED") {
+            return { errc::management::eventing_function_paused, problem };
+        }
+        if (problem.name == "ERR_BUCKET_MISSING") {
+            return { errc::common::bucket_not_found, problem };
+        }
+        if (problem.name == "ERR_INVALID_CONFIG" || problem.name == "ERR_INTER_FUNCTION_RECURSION") {
+            return { errc::common::invalid_argument, problem };
+        }
+        return { errc::common::internal_server_failure, problem };
+    }
+    return {};
+}
+
+std::optional<std::error_code>
+translate_query_error_code(std::uint64_t error, const std::string& message, std::uint64_t reason)
+{
+    switch (error) {
+        case 5000: /* IKey: "Internal Error" */
+            if (message.find(" already exists") != std::string::npos) {
+                return errc::common::index_exists;
+            }
+            if (message.find("not found.") != std::string::npos) {
+                return errc::common::index_not_found;
+            }
+            if (message.find("Bucket Not Found") != std::string::npos) {
+                return errc::common::bucket_not_found;
+            }
+            break;
+
+        case 12003: /* IKey: "datastore.couchbase.keyspace_not_found" */
+            return errc::common::bucket_not_found;
+
+        case 12004: /* IKey: "datastore.couchbase.primary_idx_not_found" */
+        case 12016: /* IKey: "datastore.couchbase.index_not_found" */
+            return errc::common::index_not_found;
+
+        case 4300: /* IKey: "plan.new_index_already_exists" */
+            return errc::common::index_exists;
+
+        case 1065: /* IKey: "service.io.request.unrecognized_parameter" */
+            return errc::common::invalid_argument;
+
+        case 1080: /* IKey: "timeout" */
+            return errc::common::unambiguous_timeout;
+
+        case 3000: /* IKey: "parse.syntax_error" */
+            return errc::common::parsing_failure;
+
+        case 4040: /* IKey: "plan.build_prepared.no_such_name" */
+        case 4050: /* IKey: "plan.build_prepared.unrecognized_prepared" */
+        case 4060: /* IKey: "plan.build_prepared.no_such_name" */
+        case 4070: /* IKey: "plan.build_prepared.decoding" */
+        case 4080: /* IKey: "plan.build_prepared.name_encoded_plan_mismatch" */
+        case 4090: /* IKey: "plan.build_prepared.name_not_in_encoded_plan" */
+            return errc::query::prepared_statement_failure;
+
+        case 12009: /* IKey: "datastore.couchbase.DML_error" */
+        {
+            if (message.find("CAS mismatch") != std::string::npos) {
+                return errc::common::cas_mismatch;
+            }
+            switch (reason) {
+                case 12033:
+                    return errc::common::cas_mismatch;
+                case 17014:
+                    return errc::key_value::document_not_found;
+                case 17012:
+                    return errc::key_value::document_exists;
+                default:
+                    return errc::query::dml_failure;
+            }
+        }
+
+        case 13014: /* IKey: "datastore.couchbase.insufficient_credentials" */
+            return errc::common::authentication_failure;
+
+        default: {
+            if ((error >= 12000 && error < 13000) || (error >= 14000 && error < 15000)) {
+                return errc::query::index_failure;
+            }
+            if (error >= 4000 && error < 5000) {
+                return errc::query::planning_failure;
+            }
+        } break;
+    }
+    return extract_common_query_error_code(error, message);
+}
+
+std::optional<std::error_code>
+translate_analytics_error_code(std::uint64_t error, const std::string& /* message */)
+{
+    switch (error) {
+        case 0:
+            return {};
+
+        case 21002: /* Request timed out and will be cancelled */
+            return errc::common::unambiguous_timeout;
+
+        case 24006: /* Link [string] does not exist | Link [string] does not exist */
+            return errc::analytics::link_not_found;
+
+        case 23007: /* Job queue is full with [string] jobs */
+            return errc::analytics::job_queue_full;
+
+        case 24044: /* Cannot find dataset [string] because there is no dataverse declared, nor an alias with name [string]! */
+        case 24045: /* Cannot find dataset [string] in dataverse [string] nor an alias with name [string]! */
+        case 24025: /* Cannot find dataset with name [string] in dataverse [string] */
+            return errc::analytics::dataset_not_found;
+
+        case 24034: /* Cannot find dataverse with name [string] */
+            return errc::analytics::dataverse_not_found;
+
+        case 24039: /* A dataverse with this name [string] already exists. */
+            return errc::analytics::dataverse_exists;
+
+        case 24040: /* A dataset with name [string] already exists in dataverse [string] */
+            return errc::analytics::dataset_exists;
+
+        case 24047: /* Cannot find index with name [string] */
+            return errc::common::index_not_found;
+
+        case 24048: /* An index with this name [string] already exists */
+            return errc::common::index_exists;
+
+        case 24055: /* Link [string] already exists */
+            return errc::analytics::link_exists;
+
+        default:
+            if (error >= 24000 && error < 25000) {
+                return errc::analytics::compilation_failure;
+            }
+            break;
+    }
+    return errc::common::internal_server_failure;
+}
+
+std::optional<std::error_code>
+translate_search_error_code(std::uint32_t status_code, const std::string& response_body)
+{
+    if (status_code == 400 || status_code == 500) {
+        if (response_body.find("no indexName:") != std::string::npos) {
+            return errc::common::index_not_found;
+        }
+        tao::json::value payload{};
+        try {
+            payload = utils::json::parse(response_body);
+        } catch (const tao::pegtl::parse_error&) {
+            return errc::common::parsing_failure;
+        }
+
+        const auto& error = payload.at("error").get_string();
+        if (error.find("index not found") != std::string::npos) {
+            return errc::common::index_not_found;
+        }
+        if (error.find("index with the same name already exists") != std::string::npos) {
+            return errc::common::index_exists;
+        }
+        if (error.find("no planPIndexes for indexName") != std::string::npos) {
+            return errc::search::index_not_ready;
+        }
+        if (error.find("num_fts_indexes (active + pending)") != std::string::npos) {
+            return errc::common::quota_limited;
+        }
+    }
+    return {};
+}
+} // namespace couchbase::core::operations::management

package/deps/couchbase-cxx-client/core/operations/management/error_utils.hxx

@@ -0,0 +1,49 @@
+/* -*- Mode: C++; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */
+/*
+ *   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.
+ *   You may obtain a copy of the License at
+ *
+ *       http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *   Unless required by applicable law or agreed to in writing, software
+ *   distributed under the License is distributed on an "AS IS" BASIS,
+ *   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *   See the License for the specific language governing permissions and
+ *   limitations under the License.
+ */
+
+#pragma once
+
+#include "eventing_problem.hxx"
+
+#include <couchbase/error_codes.hxx>
+
+#include <tao/json/forward.hpp>
+
+#include <optional>
+
+namespace couchbase::core::operations::management
+{
+
+std::error_code
+extract_common_error_code(std::uint32_t status_code, const std::string& response_body);
+
+std::optional<std::error_code>
+extract_common_query_error_code(std::uint64_t code, const std::string& message);
+
+std::pair<std::error_code, eventing_problem>
+extract_eventing_error_code(const tao::json::value& response);
+
+std::optional<std::error_code>
+translate_query_error_code(std::uint64_t error, const std::string& message, std::uint64_t reason = 0);
+
+std::optional<std::error_code>
+translate_analytics_error_code(std::uint64_t error, const std::string& message);
+
+std::optional<std::error_code>
+translate_search_error_code(std::uint32_t status_code, const std::string& response_body);
+
+} // namespace couchbase::core::operations::management

package/deps/couchbase-cxx-client/core/operations/management/eventing.hxx

@@ -0,0 +1,28 @@
+/* -*- Mode: C++; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */
+/*
+ *   Copyright 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.
+ *   You may obtain a copy of the License at
+ *
+ *       http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *   Unless required by applicable law or agreed to in writing, software
+ *   distributed under the License is distributed on an "AS IS" BASIS,
+ *   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *   See the License for the specific language governing permissions and
+ *   limitations under the License.
+ */
+
+#pragma once
+
+#include "eventing_deploy_function.hxx"
+#include "eventing_drop_function.hxx"
+#include "eventing_get_all_functions.hxx"
+#include "eventing_get_function.hxx"
+#include "eventing_get_status.hxx"
+#include "eventing_pause_function.hxx"
+#include "eventing_resume_function.hxx"
+#include "eventing_undeploy_function.hxx"
+#include "eventing_upsert_function.hxx"

package/deps/couchbase-cxx-client/core/operations/management/eventing_deploy_function.cxx

@@ -0,0 +1,55 @@
+/* -*- Mode: C++; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */
+/*
+ *   Copyright 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.
+ *   You may obtain a copy of the License at
+ *
+ *       http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *   Unless required by applicable law or agreed to in writing, software
+ *   distributed under the License is distributed on an "AS IS" BASIS,
+ *   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *   See the License for the specific language governing permissions and
+ *   limitations under the License.
+ */
+
+#include "eventing_deploy_function.hxx"
+#include "core/utils/json.hxx"
+#include "error_utils.hxx"
+
+namespace couchbase::core::operations::management
+{
+std::error_code
+eventing_deploy_function_request::encode_to(encoded_request_type& encoded, http_context& /* context */) const
+{
+    encoded.method = "POST";
+    encoded.path = fmt::format("/api/v1/functions/{}/deploy", name);
+    return {};
+}
+
+eventing_deploy_function_response
+eventing_deploy_function_request::make_response(error_context::http&& ctx, const encoded_response_type& encoded) const
+{
+    eventing_deploy_function_response response{ std::move(ctx) };
+    if (!response.ctx.ec) {
+        if (encoded.body.data().empty()) {
+            return response;
+        }
+        tao::json::value payload{};
+        try {
+            payload = utils::json::parse(encoded.body.data());
+        } catch (const tao::pegtl::parse_error&) {
+            response.ctx.ec = errc::common::parsing_failure;
+            return response;
+        }
+        auto [ec, problem] = extract_eventing_error_code(payload);
+        if (ec) {
+            response.ctx.ec = ec;
+            response.error.emplace(problem);
+        }
+    }
+    return response;
+}
+} // namespace couchbase::core::operations::management

package/deps/couchbase-cxx-client/core/operations/management/eventing_deploy_function.hxx

@@ -0,0 +1,52 @@
+/* -*- Mode: C++; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */
+/*
+ *   Copyright 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.
+ *   You may obtain a copy of the License at
+ *
+ *       http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *   Unless required by applicable law or agreed to in writing, software
+ *   distributed under the License is distributed on an "AS IS" BASIS,
+ *   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *   See the License for the specific language governing permissions and
+ *   limitations under the License.
+ */
+
+#pragma once
+
+#include "core/error_context/http.hxx"
+#include "core/io/http_context.hxx"
+#include "core/io/http_message.hxx"
+#include "core/management/eventing_function.hxx"
+#include "core/platform/uuid.h"
+#include "core/timeout_defaults.hxx"
+#include "eventing_problem.hxx"
+
+namespace couchbase::core::operations::management
+{
+struct eventing_deploy_function_response {
+    error_context::http ctx;
+    std::optional<eventing_problem> error{};
+};
+
+struct eventing_deploy_function_request {
+    using response_type = eventing_deploy_function_response;
+    using encoded_request_type = io::http_request;
+    using encoded_response_type = io::http_response;
+    using error_context_type = error_context::http;
+
+    std::string name;
+
+    static const inline service_type type = service_type::eventing;
+
+    std::optional<std::string> client_context_id{};
+    std::optional<std::chrono::milliseconds> timeout{};
+
+    [[nodiscard]] std::error_code encode_to(encoded_request_type& encoded, http_context& context) const;
+
+    [[nodiscard]] eventing_deploy_function_response make_response(error_context::http&& ctx, const encoded_response_type& encoded) const;
+};
+} // namespace couchbase::core::operations::management

package/deps/couchbase-cxx-client/core/operations/management/eventing_drop_function.cxx

@@ -0,0 +1,56 @@
+/* -*- Mode: C++; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */
+/*
+ *   Copyright 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.
+ *   You may obtain a copy of the License at
+ *
+ *       http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *   Unless required by applicable law or agreed to in writing, software
+ *   distributed under the License is distributed on an "AS IS" BASIS,
+ *   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *   See the License for the specific language governing permissions and
+ *   limitations under the License.
+ */
+
+#include "eventing_drop_function.hxx"
+#include "core/utils/json.hxx"
+#include "error_utils.hxx"
+
+namespace couchbase::core::operations::management
+{
+std::error_code
+eventing_drop_function_request::encode_to(encoded_request_type& encoded, http_context& /* context */) const
+{
+    encoded.method = "DELETE";
+    encoded.path = fmt::format("/api/v1/functions/{}", name);
+    return {};
+}
+
+eventing_drop_function_response
+eventing_drop_function_request::make_response(error_context::http&& ctx, const encoded_response_type& encoded) const
+{
+    eventing_drop_function_response response{ std::move(ctx) };
+    if (!response.ctx.ec) {
+        if (encoded.body.data().empty()) {
+            return response;
+        }
+        tao::json::value payload{};
+        try {
+            payload = utils::json::parse(encoded.body.data());
+        } catch (const tao::pegtl::parse_error&) {
+            response.ctx.ec = errc::common::parsing_failure;
+            return response;
+        }
+        auto [ec, problem] = extract_eventing_error_code(payload);
+        if (ec) {
+            response.ctx.ec = ec;
+            response.error.emplace(problem);
+            return response;
+        }
+    }
+    return response;
+}
+} // namespace couchbase::core::operations::management