couchbase 4.1.2 → 4.1.3

package/deps/couchbase-transactions-cxx/deps/couchbase-cxx-client/core/operations/management/group_drop.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 "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 group_drop_response {
+    error_context::http ctx;
+};
+
+struct group_drop_request {
+    using response_type = group_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 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]] group_drop_response make_response(error_context::http&& ctx, const encoded_response_type& encoded) const;
+};
+} // namespace couchbase::core::operations::management

package/deps/couchbase-transactions-cxx/deps/couchbase-cxx-client/core/operations/management/group_get.cxx

@@ -0,0 +1,59 @@
+/* -*- 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 "group_get.hxx"
+
+#include "core/management/rbac_json.hxx"
+#include "core/utils/json.hxx"
+#include "error_utils.hxx"
+
+namespace couchbase::core::operations::management
+{
+std::error_code
+group_get_request::encode_to(encoded_request_type& encoded, http_context& /* context */) const
+{
+    encoded.method = "GET";
+    encoded.path = fmt::format("/settings/rbac/groups/{}", name);
+    encoded.headers["content-type"] = "application/x-www-form-urlencoded";
+    return {};
+}
+
+group_get_response
+group_get_request::make_response(error_context::http&& ctx, const encoded_response_type& encoded) const
+{
+    group_get_response response{ std::move(ctx) };
+    if (!response.ctx.ec) {
+        switch (encoded.status_code) {
+            case 200: {
+                try {
+                    response.group = utils::json::parse(encoded.body.data()).as<couchbase::core::management::rbac::group>();
+                } catch (const tao::pegtl::parse_error&) {
+                    response.ctx.ec = errc::common::parsing_failure;
+                    return response;
+                }
+            } break;
+            case 404:
+                response.ctx.ec = errc::management::group_not_found;
+                break;
+            default:
+                response.ctx.ec = extract_common_error_code(encoded.status_code, encoded.body.data());
+                break;
+        }
+    }
+    return response;
+}
+} // namespace couchbase::core::operations::management

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

@@ -0,0 +1,50 @@
+/* -*- 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/management/rbac.hxx"
+#include "core/platform/uuid.h"
+#include "core/timeout_defaults.hxx"
+
+namespace couchbase::core::operations::management
+{
+struct group_get_response {
+    error_context::http ctx;
+    couchbase::core::management::rbac::group group{};
+};
+
+struct group_get_request {
+    using response_type = group_get_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 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]] group_get_response make_response(error_context::http&& ctx, const encoded_response_type& encoded) const;
+};
+} // namespace couchbase::core::operations::management

package/deps/couchbase-transactions-cxx/deps/couchbase-cxx-client/core/operations/management/group_get_all.cxx

@@ -0,0 +1,57 @@
+/* -*- 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 "group_get_all.hxx"
+
+#include "core/management/rbac_json.hxx"
+#include "core/utils/json.hxx"
+#include "error_utils.hxx"
+
+namespace couchbase::core::operations::management
+{
+std::error_code
+group_get_all_request::encode_to(encoded_request_type& encoded, http_context& /* context */) const
+{
+    encoded.method = "GET";
+    encoded.path = fmt::format("/settings/rbac/groups");
+    encoded.headers["content-type"] = "application/x-www-form-urlencoded";
+    return {};
+}
+
+group_get_all_response
+group_get_all_request::make_response(error_context::http&& ctx, const encoded_response_type& encoded) const
+{
+    group_get_all_response response{ std::move(ctx) };
+    if (!response.ctx.ec) {
+        if (encoded.status_code != 200) {
+            response.ctx.ec = extract_common_error_code(encoded.status_code, encoded.body.data());
+            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;
+        }
+        for (const auto& entry : payload.get_array()) {
+            response.groups.emplace_back(entry.as<couchbase::core::management::rbac::group>());
+        }
+    }
+    return response;
+}
+} // namespace couchbase::core::operations::management

package/deps/couchbase-transactions-cxx/deps/couchbase-cxx-client/core/operations/management/group_get_all.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 "core/error_context/http.hxx"
+#include "core/io/http_context.hxx"
+#include "core/io/http_message.hxx"
+#include "core/management/rbac.hxx"
+#include "core/platform/uuid.h"
+#include "core/timeout_defaults.hxx"
+
+namespace couchbase::core::operations::management
+{
+struct group_get_all_response {
+    error_context::http ctx;
+    std::vector<couchbase::core::management::rbac::group> groups{};
+};
+
+struct group_get_all_request {
+    using response_type = group_get_all_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::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]] group_get_all_response make_response(error_context::http&& ctx, const encoded_response_type& encoded) const;
+};
+} // namespace couchbase::core::operations::management

package/deps/couchbase-transactions-cxx/deps/couchbase-cxx-client/core/operations/management/group_upsert.cxx

@@ -0,0 +1,95 @@
+/* -*- 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 "group_upsert.hxx"
+
+#include "core/utils/join_strings.hxx"
+#include "core/utils/json.hxx"
+#include "core/utils/url_codec.hxx"
+#include "error_utils.hxx"
+
+namespace couchbase::core::operations::management
+{
+std::error_code
+group_upsert_request::encode_to(encoded_request_type& encoded, http_context& /* context */) const
+{
+    encoded.method = "PUT";
+    encoded.path = fmt::format("/settings/rbac/groups/{}", group.name);
+    std::vector<std::string> params{};
+    if (group.description) {
+        params.push_back(fmt::format("description={}", utils::string_codec::url_encode(group.description.value())));
+    }
+    if (group.ldap_group_reference) {
+        params.push_back(fmt::format("ldap_group_ref={}", utils::string_codec::url_encode(group.ldap_group_reference.value())));
+    }
+    std::vector<std::string> encoded_roles{};
+    encoded_roles.reserve(group.roles.size());
+    for (const auto& role : group.roles) {
+        std::string spec = role.name;
+        if (role.bucket) {
+            spec += fmt::format("[{}", role.bucket.value());
+            if (role.scope) {
+                spec += fmt::format(":{}", role.scope.value());
+                if (role.collection) {
+                    spec += fmt::format(":{}", role.collection.value());
+                }
+            }
+            spec += "]";
+        }
+        encoded_roles.push_back(spec);
+    }
+    if (!encoded_roles.empty()) {
+        std::string concatenated = fmt::format("{}", utils::join_strings(encoded_roles, ","));
+        params.push_back(fmt::format("roles={}", utils::string_codec::url_encode(concatenated)));
+    }
+    encoded.body = utils::join_strings(params, "&");
+    encoded.headers["content-type"] = "application/x-www-form-urlencoded";
+    return {};
+}
+
+group_upsert_response
+group_upsert_request::make_response(error_context::http&& ctx, const encoded_response_type& encoded) const
+{
+    group_upsert_response response{ std::move(ctx) };
+    if (!response.ctx.ec) {
+        switch (encoded.status_code) {
+            case 200:
+                break;
+            case 400: {
+                response.ctx.ec = errc::common::invalid_argument;
+                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;
+                }
+
+                if (const auto* errors = payload.find("errors"); errors != nullptr && errors->is_object()) {
+                    for (const auto& [code, message] : errors->get_object()) {
+                        response.errors.emplace_back(fmt::format("{}: {}", code, message.get_string()));
+                    }
+                }
+            } break;
+            default:
+                response.ctx.ec = extract_common_error_code(encoded.status_code, encoded.body.data());
+                break;
+        }
+    }
+    return response;
+}
+} // namespace couchbase::core::operations::management

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

@@ -0,0 +1,51 @@
+/* -*- 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/management/rbac.hxx"
+#include "core/platform/uuid.h"
+#include "core/timeout_defaults.hxx"
+
+namespace couchbase::core::operations::management
+{
+struct group_upsert_response {
+    error_context::http ctx;
+    std::vector<std::string> errors{};
+};
+
+struct group_upsert_request {
+    using response_type = group_upsert_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;
+
+    couchbase::core::management::rbac::group group{};
+
+    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]] group_upsert_response make_response(error_context::http&& ctx, const encoded_response_type& encoded) const;
+};
+} // namespace couchbase::core::operations::management

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

@@ -0,0 +1,24 @@
+/* -*- 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 "query_index_build.hxx"
+#include "query_index_create.hxx"
+#include "query_index_drop.hxx"
+#include "query_index_get_all.hxx"
+#include "query_index_get_all_deferred.hxx"

package/deps/couchbase-transactions-cxx/deps/couchbase-cxx-client/core/operations/management/query_index_build.cxx

@@ -0,0 +1,93 @@
+/* -*- 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 "query_index_build.hxx"
+
+#include "core/utils/join_strings.hxx"
+#include "core/utils/json.hxx"
+#include "error_utils.hxx"
+
+namespace couchbase::core::operations::management
+{
+
+template<typename Range>
+std::string
+quote_and_join_strings(const Range& values, const std::string& sep)
+{
+    std::stringstream stream;
+    auto sentinel = std::end(values);
+    if (auto it = std::begin(values); it != sentinel) {
+        stream << '`' << *it << '`';
+        ++it;
+        while (it != sentinel) {
+            stream << sep << *it;
+            ++it;
+        }
+    }
+    return stream.str();
+}
+
+std::error_code
+query_index_build_request::encode_to(encoded_request_type& encoded, http_context& /* context */) const
+{
+    if ((scope_name.empty() && !collection_name.empty()) || (!scope_name.empty() && collection_name.empty()) || index_names.empty()) {
+        return errc::common::invalid_argument;
+    }
+    std::string statement;
+    if (!scope_name.empty() && !collection_name.empty()) {
+        statement = fmt::format(
+          R"(BUILD INDEX ON `{}`.`{}`.`{}` ({}))", bucket_name, scope_name, collection_name, quote_and_join_strings(index_names, ","));
+    } else {
+        statement = fmt::format(R"(BUILD INDEX ON `{}` ({}))", bucket_name, quote_and_join_strings(index_names, ","));
+    }
+    encoded.headers["content-type"] = "application/json";
+    tao::json::value body{ { "statement", statement }, { "client_context_id", encoded.client_context_id } };
+    encoded.method = "POST";
+    encoded.path = "/query/service";
+    encoded.body = utils::json::generate(body);
+    return {};
+}
+
+query_index_build_response
+query_index_build_request::make_response(error_context::http&& ctx, const encoded_response_type& encoded) const
+{
+    query_index_build_response response{ std::move(ctx) };
+    if (!response.ctx.ec) {
+        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;
+        }
+        response.status = payload.at("status").get_string();
+        if (response.status != "success") {
+            std::optional<std::error_code> common_ec{};
+            for (const auto& entry : payload.at("errors").get_array()) {
+                query_index_build_response::query_problem error;
+                error.code = entry.at("code").get_unsigned();
+                error.message = entry.at("msg").get_string();
+                response.errors.emplace_back(error);
+                common_ec = management::extract_common_query_error_code(error.code, error.message);
+            }
+
+            response.ctx.ec = common_ec.value_or(extract_common_error_code(encoded.status_code, encoded.body.data()));
+        }
+    }
+    return response;
+}
+} // namespace couchbase::core::operations::management

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

@@ -0,0 +1,60 @@
+/* -*- 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 query_index_build_response {
+    struct query_problem {
+        std::uint64_t code;
+        std::string message;
+    };
+    error_context::http ctx;
+    std::string status{};
+    std::vector<query_problem> errors{};
+};
+
+struct query_index_build_request {
+    using response_type = query_index_build_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::query;
+
+    std::string bucket_name;
+    std::string scope_name;
+    std::string collection_name;
+
+    std::vector<std::string> index_names;
+
+    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]] query_index_build_response make_response(error_context::http&& ctx, const encoded_response_type& encoded) const;
+};
+
+} // namespace couchbase::core::operations::management