couchbase 3.4.4 → 3.4.5

data/ext/couchbase/core/impl/update_collection.cxx

@@ -0,0 +1,83 @@
+/* -*- Mode: C++; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */
+/*
+ *   Copyright 2020-Present 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 <couchbase/manager_error_context.hxx>
+
+#include "core/cluster.hxx"
+#include "core/operations/management/collection_update.hxx"
+#include "couchbase/collection_manager.hxx"
+
+namespace couchbase
+{
+template<typename Response>
+static manager_error_context
+build_context(Response& resp)
+{
+    return manager_error_context(internal_manager_error_context{ resp.ctx.ec,
+                                                                 resp.ctx.last_dispatched_to,
+                                                                 resp.ctx.last_dispatched_from,
+                                                                 resp.ctx.retry_attempts,
+                                                                 std::move(resp.ctx.retry_reasons),
+                                                                 std::move(resp.ctx.client_context_id),
+                                                                 resp.ctx.http_status,
+                                                                 std::move(resp.ctx.http_body),
+                                                                 std::move(resp.ctx.path) });
+}
+
+static core::operations::management::collection_update_request
+build_collection_update_request(std::string bucket_name,
+                                std::string scope_name,
+                                std::string collection_name,
+                                const update_collection_settings& settings,
+                                const update_collection_options::built& options)
+{
+    core::operations::management::collection_update_request request{
+        std::move(bucket_name), std::move(scope_name), std::move(collection_name), settings.max_expiry, settings.history, {},
+        options.timeout
+    };
+    return request;
+}
+
+void
+collection_manager::update_collection(std::string scope_name,
+                                      std::string collection_name,
+                                      const couchbase::update_collection_settings& settings,
+                                      const couchbase::update_collection_options& options,
+                                      couchbase::update_collection_handler&& handler) const
+{
+    auto request =
+      build_collection_update_request(bucket_name_, std::move(scope_name), std::move(collection_name), settings, options.build());
+
+    core_->execute(std::move(request),
+                   [handler = std::move(handler)](core::operations::management::collection_update_response resp) mutable {
+                       return handler(build_context(resp));
+                   });
+}
+
+auto
+collection_manager::update_collection(std::string scope_name,
+                                      std::string collection_name,
+                                      const couchbase::update_collection_settings& settings,
+                                      const couchbase::update_collection_options& options) const -> std::future<manager_error_context>
+{
+    auto barrier = std::make_shared<std::promise<manager_error_context>>();
+    update_collection(std::move(scope_name), std::move(collection_name), settings, options, [barrier](auto ctx) mutable {
+        barrier->set_value(std::move(ctx));
+    });
+    return barrier->get_future();
+}
+} // namespace couchbase

data/ext/couchbase/core/management/bucket_settings.hxx

@@ -105,16 +105,19 @@ struct bucket_settings {
 
     std::string name;
     std::string uuid;
+    std::uint64_t ram_quota_mb{ 0 }; // If not explicitly set, defaults to 100 on create_bucket, unset on update_bucket
     cluster::bucket_type bucket_type{ cluster::bucket_type::unknown };
-    std::uint64_t ram_quota_mb{ 100 };
-    std::uint32_t max_expiry{ 0 };
+    std::optional<std::uint32_t> max_expiry{};
     bucket_compression compression_mode{ bucket_compression::unknown };
     std::optional<couchbase::durability_level> minimum_durability_level{};
-    std::uint32_t num_replicas{ 1 };
-    bool replica_indexes{ false };
-    bool flush_enabled{ false };
+    std::optional<std::uint32_t> num_replicas{};
+    std::optional<bool> replica_indexes{};
+    std::optional<bool> flush_enabled{};
     bucket_eviction_policy eviction_policy{ bucket_eviction_policy::unknown };
     bucket_conflict_resolution conflict_resolution_type{ bucket_conflict_resolution::unknown };
+    std::optional<bool> history_retention_collection_default{};
+    std::optional<std::uint32_t> history_retention_bytes;
+    std::optional<std::uint32_t> history_retention_duration{};
 
     /**
      * UNCOMMITTED: This API may change in the future

data/ext/couchbase/core/management/bucket_settings_json.hxx

@@ -33,10 +33,20 @@ struct traits<couchbase::core::management::cluster::bucket_settings> {
         result.uuid = v.at("uuid").get_string();
         const static std::uint64_t megabyte = 1024LLU * 1024LLU;
         result.ram_quota_mb = v.at("quota").at("rawRAM").get_unsigned() / megabyte;
-        result.num_replicas = v.at("replicaNumber").template as<std::uint32_t>();
+        result.num_replicas = v.at("replicaNumber").template as<std::optional<std::uint32_t>>();
 
         if (auto* max_ttl = v.find("maxTTL"); max_ttl != nullptr) {
-            result.max_expiry = max_ttl->template as<std::uint32_t>();
+            result.max_expiry = max_ttl->template as<std::optional<std::uint32_t>>();
+        }
+
+        if (auto* history_retention_default = v.find("historyRetentionCollectionDefault"); history_retention_default != nullptr) {
+            result.history_retention_collection_default = history_retention_default->template as<std::optional<bool>>();
+        }
+        if (auto* history_retention_bytes = v.find("historyRetentionBytes"); history_retention_bytes != nullptr) {
+            result.history_retention_bytes = history_retention_bytes->template as<std::optional<std::uint32_t>>();
+        }
+        if (auto* history_retention_duration = v.find("historyRetentionSeconds"); history_retention_duration != nullptr) {
+            result.history_retention_duration = history_retention_duration->template as<std::optional<std::uint32_t>>();
         }
 
         if (auto& str = v.at("bucketType").get_string(); str == "couchbase" || str == "membase") {

data/ext/couchbase/core/meta/features.hxx

@@ -54,3 +54,20 @@
  * couchbase::core::lookup_in_replica support
  */
 #define COUCHBASE_CXX_CLIENT_CORE_HAS_SUBDOC_READ_REPLICA 1
+
+/**
+ * Collection management is accessible from the public API
+ * couchbase::bucket::collections() support
+ */
+#define COUCHBASE_CXX_CLIENT_HAS_PUBLIC_COLLECTION_MANAGEMENT 1
+
+/**
+ * Support for bucket no-deduplication feature in bucket and collection management
+ */
+#define COUCHBASE_CXX_CLIENT_HAS_BUCKET_NO_DEDUP 1
+
+/**
+ * Collection query index management is available in the public API
+ * couchbase::collection::query_indexes() support
+ */
+#define COUCHBASE_CXX_CLIENT_HAS_COLLECTION_QUERY_INDEX_MANAGEMENT 1

data/ext/couchbase/core/operations/document_lookup_in.cxx

@@ -70,6 +70,9 @@ lookup_in_request::make_response(key_value_error_context&& ctx, const encoded_re
             fields[i].status = res_entry.status;
             fields[i].ec =
               protocol::map_status_code(protocol::client_opcode::subdoc_multi_mutation, static_cast<std::uint16_t>(res_entry.status));
+            if (fields[i].opcode == protocol::subdoc_opcode::exists && fields[i].ec == errc::key_value::path_not_found) {
+                fields[i].ec.clear();
+            }
             if (!fields[i].ec && !ctx.ec()) {
                 ec = fields[i].ec;
             }
@@ -79,7 +82,11 @@ lookup_in_request::make_response(key_value_error_context&& ctx, const encoded_re
             }
             fields[i].exists =
               res_entry.status == key_value_status_code::success || res_entry.status == key_value_status_code::subdoc_success_deleted;
-            fields[i].value = utils::to_binary(res_entry.value);
+            if (fields[i].opcode == protocol::subdoc_opcode::exists && !fields[i].ec) {
+                fields[i].value = utils::json::generate_binary(fields[i].exists);
+            } else {
+                fields[i].value = utils::to_binary(res_entry.value);
+            }
         }
         if (!ec) {
             cas = encoded.cas();

data/ext/couchbase/core/operations/management/CMakeLists.txt

@@ -28,6 +28,7 @@ add_library(
         collection_create.cxx
         collection_drop.cxx
         collections_manifest_get.cxx
+        collection_update.cxx
         error_utils.cxx
         eventing_deploy_function.cxx
         eventing_drop_function.cxx

data/ext/couchbase/core/operations/management/bucket_create.cxx

@@ -48,17 +48,35 @@ bucket_create_request::encode_to(encoded_request_type& encoded, http_context& /*
         case couchbase::core::management::cluster::bucket_type::unknown:
             break;
     }
-    encoded.body.append(fmt::format("&ramQuotaMB={}", bucket.ram_quota_mb));
-    if (bucket.bucket_type != couchbase::core::management::cluster::bucket_type::memcached) {
-        encoded.body.append(fmt::format("&replicaNumber={}", bucket.num_replicas));
+    if (bucket.ram_quota_mb == 0) {
+        encoded.body.append(fmt::format("&ramQuotaMB={}", 100)); // If not explicitly set, set to prior default value of 100
+    } else {
+        encoded.body.append(fmt::format("&ramQuotaMB={}", bucket.ram_quota_mb));
     }
-    if (bucket.max_expiry > 0) {
-        encoded.body.append(fmt::format("&maxTTL={}", bucket.max_expiry));
+
+    if (bucket.bucket_type != couchbase::core::management::cluster::bucket_type::memcached && bucket.num_replicas.has_value()) {
+        encoded.body.append(fmt::format("&replicaNumber={}", bucket.num_replicas.value()));
+    }
+    if (bucket.max_expiry.has_value()) {
+        encoded.body.append(fmt::format("&maxTTL={}", bucket.max_expiry.value()));
+    }
+    if (bucket.bucket_type != couchbase::core::management::cluster::bucket_type::ephemeral && bucket.replica_indexes.has_value()) {
+        encoded.body.append(fmt::format("&replicaIndex={}", bucket.replica_indexes.value() ? "1" : "0"));
+    }
+    if (bucket.history_retention_collection_default.has_value()) {
+        encoded.body.append(
+          fmt::format("&historyRetentionCollectionDefault={}", bucket.history_retention_collection_default.value() ? "true" : "false"));
     }
-    if (bucket.bucket_type != couchbase::core::management::cluster::bucket_type::ephemeral) {
-        encoded.body.append(fmt::format("&replicaIndex={}", bucket.replica_indexes ? "1" : "0"));
+    if (bucket.history_retention_bytes.has_value()) {
+        encoded.body.append(fmt::format("&historyRetentionBytes={}", bucket.history_retention_bytes.value()));
     }
-    encoded.body.append(fmt::format("&flushEnabled={}", bucket.flush_enabled ? "1" : "0"));
+    if (bucket.history_retention_duration.has_value()) {
+        encoded.body.append(fmt::format("&historyRetentionSeconds={}", bucket.history_retention_duration.value()));
+    }
+    if (bucket.flush_enabled.has_value()) {
+        encoded.body.append(fmt::format("&flushEnabled={}", bucket.flush_enabled.value() ? "1" : "0"));
+    }
+
     switch (bucket.eviction_policy) {
         case couchbase::core::management::cluster::bucket_eviction_policy::full:
             encoded.body.append("&evictionPolicy=fullEviction");
@@ -101,7 +119,7 @@ bucket_create_request::encode_to(encoded_request_type& encoded, http_context& /*
         case couchbase::core::management::cluster::bucket_conflict_resolution::unknown:
             break;
     }
-    if (bucket.minimum_durability_level) {
+    if (bucket.minimum_durability_level.has_value()) {
         switch (bucket.minimum_durability_level.value()) {
             case durability_level::none:
                 encoded.body.append("&durabilityMinLevel=none");
@@ -151,6 +169,9 @@ bucket_create_request::make_response(error_context::http&& ctx, const encoded_re
                 if (errors != nullptr) {
                     std::vector<std::string> error_list{};
                     for (const auto& [code, message] : errors->get_object()) {
+                        if (message.get_string().find("Bucket with given name already exists") != std::string::npos) {
+                            response.ctx.ec = errc::management::bucket_exists;
+                        }
                         error_list.emplace_back(message.get_string());
                     }
                     if (!error_list.empty()) {

data/ext/couchbase/core/operations/management/bucket_update.cxx

@@ -33,13 +33,34 @@ bucket_update_request::encode_to(encoded_request_type& encoded, http_context& /*
     encoded.path = fmt::format("/pools/default/buckets/{}", bucket.name);
 
     encoded.headers["content-type"] = "application/x-www-form-urlencoded";
-    encoded.body.append(fmt::format("&ramQuotaMB={}", bucket.ram_quota_mb));
-    encoded.body.append(fmt::format("&replicaNumber={}", bucket.num_replicas));
-    if (bucket.max_expiry > 0) {
-        encoded.body.append(fmt::format("&maxTTL={}", bucket.max_expiry));
+
+    if (bucket.ram_quota_mb > 0) {
+        encoded.body.append(fmt::format("&ramQuotaMB={}", bucket.ram_quota_mb));
+    }
+    if (bucket.num_replicas.has_value()) {
+        encoded.body.append(fmt::format("&replicaNumber={}", bucket.num_replicas.value()));
+    }
+
+    if (bucket.max_expiry.has_value()) {
+        encoded.body.append(fmt::format("&maxTTL={}", bucket.max_expiry.value()));
+    }
+    if (bucket.history_retention_collection_default.has_value()) {
+        encoded.body.append(
+          fmt::format("&historyRetentionCollectionDefault={}", bucket.history_retention_collection_default.value() ? "true" : "false"));
     }
-    encoded.body.append(fmt::format("&replicaIndex={}", bucket.replica_indexes ? "1" : "0"));
-    encoded.body.append(fmt::format("&flushEnabled={}", bucket.flush_enabled ? "1" : "0"));
+    if (bucket.history_retention_bytes.has_value()) {
+        encoded.body.append(fmt::format("&historyRetentionBytes={}", bucket.history_retention_bytes.value()));
+    }
+    if (bucket.history_retention_duration.has_value()) {
+        encoded.body.append(fmt::format("&historyRetentionSeconds={}", bucket.history_retention_duration.value()));
+    }
+    if (bucket.replica_indexes.has_value()) {
+        encoded.body.append(fmt::format("&replicaIndex={}", bucket.replica_indexes.value() ? "1" : "0"));
+    }
+    if (bucket.flush_enabled.has_value()) {
+        encoded.body.append(fmt::format("&flushEnabled={}", bucket.flush_enabled.value() ? "1" : "0"));
+    }
+
     switch (bucket.eviction_policy) {
         case couchbase::core::management::cluster::bucket_eviction_policy::full:
             encoded.body.append("&evictionPolicy=fullEviction");

data/ext/couchbase/core/operations/management/collection_create.cxx

@@ -35,6 +35,9 @@ collection_create_request::encode_to(encoded_request_type& encoded, http_context
     if (max_expiry > 0) {
         encoded.body.append(fmt::format("&maxTTL={}", max_expiry));
     }
+    if (history.has_value()) {
+        encoded.body.append(fmt::format("&history={}", history.value()));
+    }
     return {};
 }
 
@@ -48,7 +51,8 @@ collection_create_request::make_response(error_context::http&& ctx, const encode
                 std::regex collection_exists("Collection with name .+ already exists");
                 if (std::regex_search(encoded.body.data(), collection_exists)) {
                     response.ctx.ec = errc::management::collection_exists;
-                } else if (encoded.body.data().find("Not allowed on this version of cluster") != std::string::npos) {
+                } else if (encoded.body.data().find("Not allowed on this version of cluster") != std::string::npos ||
+                           encoded.body.data().find("Bucket must have storage_mode=magma") != std::string::npos) {
                     response.ctx.ec = errc::common::feature_not_available;
                 } else {
                     response.ctx.ec = errc::common::invalid_argument;

data/ext/couchbase/core/operations/management/collection_create.hxx

@@ -42,6 +42,7 @@ struct collection_create_request {
     std::string scope_name;
     std::string collection_name;
     std::uint32_t max_expiry{ 0 };
+    std::optional<bool> history{};
 
     std::optional<std::string> client_context_id{};
     std::optional<std::chrono::milliseconds> timeout{};

data/ext/couchbase/core/operations/management/collection_update.cxx

@@ -0,0 +1,87 @@
+/* -*- 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 "collection_update.hxx"
+
+#include "core/utils/json.hxx"
+#include "core/utils/url_codec.hxx"
+#include "error_utils.hxx"
+
+#include <regex>
+
+namespace couchbase::core::operations::management
+{
+std::error_code
+collection_update_request::encode_to(encoded_request_type& encoded, http_context& /* context */) const
+{
+    encoded.method = "PATCH";
+    encoded.path = fmt::format("/pools/default/buckets/{}/scopes/{}/collections/{}", bucket_name, scope_name, collection_name);
+    encoded.headers["content-type"] = "application/x-www-form-urlencoded";
+    std::map<std::string, std::string> values{};
+    if (max_expiry.has_value()) {
+        values["maxTTL"] = std::to_string(max_expiry.value());
+    }
+    if (history.has_value()) {
+        values["history"] = history.value() ? "true" : "false";
+    }
+    encoded.body = utils::string_codec::v2::form_encode(values);
+    return {};
+}
+
+collection_update_response
+collection_update_request::make_response(error_context::http&& ctx, const encoded_response_type& encoded) const
+{
+    collection_update_response response{ std::move(ctx) };
+    if (!response.ctx.ec) {
+        switch (encoded.status_code) {
+            case 400: {
+                if (encoded.body.data().find("Not allowed on this version of cluster") != std::string::npos ||
+                    encoded.body.data().find("Bucket must have storage_mode=magma") != std::string::npos) {
+                    response.ctx.ec = errc::common::feature_not_available;
+                } else {
+                    response.ctx.ec = errc::common::invalid_argument;
+                }
+            } break;
+            case 404: {
+                std::regex scope_not_found("Scope with name .+ is not found");
+                std::regex collection_not_found("Collection with name .+ is not found");
+                if (std::regex_search(encoded.body.data(), collection_not_found)) {
+                    response.ctx.ec = errc::common::collection_not_found;
+                } else if (std::regex_search(encoded.body.data(), scope_not_found)) {
+                    response.ctx.ec = errc::common::scope_not_found;
+                } else {
+                    response.ctx.ec = errc::common::bucket_not_found;
+                }
+            } break;
+            case 200: {
+                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.uid = std::stoull(payload.at("uid").get_string(), nullptr, 16);
+            } break;
+            default:
+                response.ctx.ec = extract_common_error_code(encoded.status_code, encoded.body.data());
+                break;
+        }
+    }
+    return response;
+}
+} // namespace couchbase::core::operations::management

data/ext/couchbase/core/operations/management/collection_update.hxx

@@ -0,0 +1,54 @@
+/* -*- 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_update_response {
+    error_context::http ctx;
+    std::uint64_t uid{ 0 };
+};
+
+struct collection_update_request {
+    using response_type = collection_update_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::uint32_t> max_expiry{};
+    std::optional<bool> history{};
+
+    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_update_response make_response(error_context::http&& ctx, const encoded_response_type& encoded) const;
+};
+} // namespace couchbase::core::operations::management

data/ext/couchbase/core/operations/management/collections.hxx

@@ -19,6 +19,7 @@
 
 #include "collection_create.hxx"
 #include "collection_drop.hxx"
+#include "collection_update.hxx"
 #include "collections_manifest_get.hxx"
 #include "scope_create.hxx"
 #include "scope_drop.hxx"

data/ext/couchbase/core/timeout_defaults.hxx

@@ -40,5 +40,5 @@ constexpr std::chrono::milliseconds tcp_keep_alive_interval{ 60'000 };
 constexpr std::chrono::milliseconds config_poll_interval{ 2'500 };
 constexpr std::chrono::milliseconds config_poll_floor{ 50 };
 constexpr std::chrono::milliseconds config_idle_redial_timeout{ 5 * 60'000 };
-constexpr std::chrono::milliseconds idle_http_connection_timeout{ 4'500 };
+constexpr std::chrono::milliseconds idle_http_connection_timeout{ 1'000 };
 } // namespace couchbase::core::timeout_defaults

data/ext/couchbase/core/topology/capabilities.hxx

@@ -33,6 +33,7 @@ enum class bucket_capability {
     tombstoned_user_xattrs,
     range_scan,
     replica_read,
+    non_deduped_history,
 };
 
 enum class cluster_capability {

data/ext/couchbase/core/topology/capabilities_fmt.hxx

@@ -73,6 +73,9 @@ struct fmt::formatter<couchbase::core::bucket_capability> {
             case couchbase::core::bucket_capability::replica_read:
                 name = "replica_read";
                 break;
+            case couchbase::core::bucket_capability::non_deduped_history:
+                name = "non_deduped_history";
+                break;
         }
         return format_to(ctx.out(), "{}", name);
     }

data/ext/couchbase/core/topology/collections_manifest.hxx

@@ -17,6 +17,7 @@
 
 #pragma once
 
+#include <optional>
 #include <vector>
 
 #include "core/platform/uuid.h"
@@ -28,6 +29,7 @@ struct collections_manifest {
         std::uint64_t uid;
         std::string name;
         std::uint32_t max_expiry{ 0 };
+        std::optional<bool> history{};
     };
 
     struct scope {

data/ext/couchbase/core/topology/collections_manifest_json.hxx

@@ -43,6 +43,9 @@ struct traits<couchbase::core::topology::collections_manifest> {
                 if (const auto* max_ttl = c.find("maxTTL"); max_ttl != nullptr) {
                     collection.max_expiry = max_ttl->template as<std::uint32_t>();
                 }
+                if (const auto* history = c.find("history"); history != nullptr) {
+                    collection.history = history->template as<std::optional<bool>>();
+                }
                 scope.collections.emplace_back(collection);
             }
             result.scopes.emplace_back(scope);

data/ext/couchbase/core/topology/configuration.hxx

@@ -134,6 +134,11 @@ struct configuration {
         return bucket_capabilities.find(bucket_capability::replica_read) != bucket_capabilities.end();
     }
 
+    [[nodiscard]] bool supports_non_deduped_history() const
+    {
+        return bucket_capabilities.find(bucket_capability::non_deduped_history) != bucket_capabilities.end();
+    }
+
     [[nodiscard]] std::size_t index_for_this_node() const;
     [[nodiscard]] bool has_node(const std::string& network,
                                 service_type type,

data/ext/couchbase/core/topology/configuration_json.hxx

@@ -236,6 +236,8 @@ struct traits<couchbase::core::topology::configuration> {
                     result.bucket_capabilities.insert(couchbase::core::bucket_capability::range_scan);
                 } else if (name == "subdoc.ReplicaRead") {
                     result.bucket_capabilities.insert(couchbase::core::bucket_capability::replica_read);
+                } else if (name == "nonDedupedHistory") {
+                    result.bucket_capabilities.insert(couchbase::core::bucket_capability::non_deduped_history);
                 }
             }
         }

data/ext/couchbase/couchbase/bucket.hxx

@@ -18,6 +18,7 @@
 #pragma once
 
 #include <couchbase/collection.hxx>
+#include <couchbase/collection_manager.hxx>
 #include <couchbase/scope.hxx>
 
 #include <memory>
@@ -82,6 +83,19 @@ class bucket
         return { core_, name_, scope_name };
     }
 
+    /**
+     * Provides access to the collection management services.
+     *
+     * @return a manager instance
+     *
+     * @since 1.0.0
+     * @committed
+     */
+    [[nodiscard]] auto collections() const -> collection_manager
+    {
+        return collection_manager{ core_, name_ };
+    }
+
   private:
     friend class cluster;