couchbase 3.6.0 → 3.7.0

data/ext/couchbase/couchbase/collection.hxx

@@ -58,6 +58,10 @@ class cluster;
 class bucket;
 class scope;
 class collection_impl;
+namespace crypto
+{
+class manager;
+} // namespace crypto
 #endif
 
 /**
@@ -460,7 +464,7 @@ public:
               upsert_handler&& handler) const
   {
     return upsert(
-      std::move(document_id), Transcoder::encode(document), options, std::move(handler));
+      std::move(document_id), encode_document<Transcoder>(document), options, std::move(handler));
   }
 
   /**
@@ -506,7 +510,7 @@ public:
                             const upsert_options& options = {}) const
     -> std::future<std::pair<error, mutation_result>>
   {
-    return upsert(std::move(document_id), Transcoder::encode(document), options);
+    return upsert(std::move(document_id), encode_document<Transcoder>(document), options);
   }
 
   /**
@@ -556,7 +560,7 @@ public:
               insert_handler&& handler) const
   {
     return insert(
-      std::move(document_id), Transcoder::encode(document), options, std::move(handler));
+      std::move(document_id), encode_document<Transcoder>(document), options, std::move(handler));
   }
 
   /**
@@ -605,7 +609,7 @@ public:
                             const insert_options& options = {}) const
     -> std::future<std::pair<error, mutation_result>>
   {
-    return insert(std::move(document_id), Transcoder::encode(document), options);
+    return insert(std::move(document_id), encode_document<Transcoder>(document), options);
   }
 
   /**
@@ -657,7 +661,7 @@ public:
                replace_handler&& handler) const
   {
     return replace(
-      std::move(document_id), Transcoder::encode(document), options, std::move(handler));
+      std::move(document_id), encode_document<Transcoder>(document), options, std::move(handler));
   }
 
   /**
@@ -708,7 +712,7 @@ public:
                              const replace_options& options = {}) const
     -> std::future<std::pair<error, mutation_result>>
   {
-    return replace(std::move(document_id), Transcoder::encode(document), options);
+    return replace(std::move(document_id), encode_document<Transcoder>(document), options);
   }
 
   /**
@@ -1083,10 +1087,23 @@ private:
   friend class bucket;
   friend class scope;
 
+  [[nodiscard]] auto crypto_manager() const -> const std::shared_ptr<crypto::manager>&;
+
+  template<typename Transcoder, typename Document>
+  [[nodiscard]] auto encode_document(const Document& document) const -> codec::encoded_value
+  {
+    if constexpr (codec::is_crypto_transcoder_v<Transcoder>) {
+      return Transcoder::encode(document, crypto_manager());
+    } else {
+      return Transcoder::encode(document);
+    }
+  }
+
   collection(core::cluster core,
              std::string_view bucket_name,
              std::string_view scope_name,
-             std::string_view name);
+             std::string_view name,
+             std::shared_ptr<crypto::manager> crypto_manager);
 
   std::shared_ptr<collection_impl> impl_;
 };

data/ext/couchbase/couchbase/crypto/internal.hxx

@@ -0,0 +1,44 @@
+/* -*- Mode: C++; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */
+/*
+ *   Copyright 2025 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 <couchbase/error.hxx>
+
+#include <cstddef>
+#include <utility>
+#include <vector>
+
+namespace couchbase::crypto::internal
+{
+auto
+generate_initialization_vector() -> std::pair<error, std::vector<std::byte>>;
+
+namespace aead_aes_256_cbc_hmac_sha512
+{
+auto
+encrypt(std::vector<std::byte> key,
+        std::vector<std::byte> iv,
+        std::vector<std::byte> plaintext,
+        std::vector<std::byte> associated_data) -> std::pair<error, std::vector<std::byte>>;
+
+auto
+decrypt(std::vector<std::byte> key,
+        std::vector<std::byte> ciphertext,
+        std::vector<std::byte> associated_data) -> std::pair<error, std::vector<std::byte>>;
+} // namespace aead_aes_256_cbc_hmac_sha512
+} // namespace couchbase::crypto::internal

data/ext/couchbase/couchbase/fmt/persist_to.hxx

@@ -0,0 +1,62 @@
+/* -*- 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.
+ */
+
+#pragma once
+
+#include <couchbase/persist_to.hxx>
+
+/**
+ * Helper for fmtlib to format @ref couchbase::persist_to objects.
+ *
+ * @since 1.2.0
+ * @committed
+ */
+template<>
+struct fmt::formatter<couchbase::persist_to> {
+  template<typename ParseContext>
+  constexpr auto parse(ParseContext& ctx)
+  {
+    return ctx.begin();
+  }
+
+  template<typename FormatContext>
+  auto format(couchbase::persist_to value, FormatContext& ctx) const
+  {
+    string_view name = "unknown";
+    switch (value) {
+      case couchbase::persist_to::none:
+        name = "none";
+        break;
+      case couchbase::persist_to::active:
+        name = "active";
+        break;
+      case couchbase::persist_to::one:
+        name = "one";
+        break;
+      case couchbase::persist_to::two:
+        name = "two";
+        break;
+      case couchbase::persist_to::three:
+        name = "three";
+        break;
+      case couchbase::persist_to::four:
+        name = "four";
+        break;
+    }
+    return format_to(ctx.out(), "{}", name);
+  }
+};

data/ext/couchbase/couchbase/fmt/replicate_to.hxx

@@ -0,0 +1,56 @@
+/* -*- 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.
+ */
+
+#pragma once
+
+#include <couchbase/replicate_to.hxx>
+
+/**
+ * Helper for fmtlib to format @ref couchbase::replicate_to objects.
+ *
+ * @since 1.2.0
+ * @committed
+ */
+template<>
+struct fmt::formatter<couchbase::replicate_to> {
+  template<typename ParseContext>
+  constexpr auto parse(ParseContext& ctx)
+  {
+    return ctx.begin();
+  }
+
+  template<typename FormatContext>
+  auto format(couchbase::replicate_to value, FormatContext& ctx) const
+  {
+    string_view name = "unknown";
+    switch (value) {
+      case couchbase::replicate_to::none:
+        name = "none";
+        break;
+      case couchbase::replicate_to::one:
+        name = "one";
+        break;
+      case couchbase::replicate_to::two:
+        name = "two";
+        break;
+      case couchbase::replicate_to::three:
+        name = "three";
+        break;
+    }
+    return format_to(ctx.out(), "{}", name);
+  }
+};

data/ext/couchbase/couchbase/get_replica_result.hxx

@@ -24,6 +24,12 @@
 
 namespace couchbase
 {
+#ifndef COUCHBASE_CXX_CLIENT_DOXYGEN
+namespace crypto
+{
+class manager;
+} // namespace crypto
+#endif
 
 /**
  * Represents result of @ref collection#get_any_replica operations, also returned by @ref
@@ -51,10 +57,14 @@ public:
    * @since 1.0.0
    * @committed
    */
-  get_replica_result(couchbase::cas cas, bool is_replica, codec::encoded_value value)
+  get_replica_result(couchbase::cas cas,
+                     bool is_replica,
+                     codec::encoded_value value,
+                     std::shared_ptr<crypto::manager> crypto_manager = {})
     : result{ cas }
     , is_replica_{ is_replica }
     , value_{ std::move(value) }
+    , crypto_manager_{ std::move(crypto_manager) }
   {
   }
 
@@ -90,7 +100,11 @@ public:
   template<typename Transcoder, std::enable_if_t<codec::is_transcoder_v<Transcoder>, bool> = true>
   [[nodiscard]] auto content_as() const -> typename Transcoder::document_type
   {
-    return Transcoder::decode(value_);
+    if constexpr (codec::is_crypto_transcoder_v<Transcoder>) {
+      return Transcoder::decode(value_, crypto_manager_);
+    } else {
+      return Transcoder::decode(value_);
+    }
   }
 
   /**
@@ -110,12 +124,17 @@ public:
            std::enable_if_t<codec::is_transcoder_v<Transcoder>, bool> = true>
   [[nodiscard]] auto content_as() const -> Document
   {
-    return Transcoder::template decode<Document>(value_);
+    if constexpr (codec::is_crypto_transcoder_v<Transcoder>) {
+      return Transcoder::template decode<Document>(value_, crypto_manager_);
+    } else {
+      return Transcoder::template decode<Document>(value_);
+    }
   }
 
 private:
   bool is_replica_{ false };
   codec::encoded_value value_{};
+  std::shared_ptr<crypto::manager> crypto_manager_{};
 };
 
 } // namespace couchbase

data/ext/couchbase/couchbase/get_result.hxx

@@ -22,11 +22,18 @@
 
 #include <chrono>
 #include <cinttypes>
+#include <memory>
 #include <optional>
 #include <vector>
 
 namespace couchbase
 {
+#ifndef COUCHBASE_CXX_CLIENT_DOXYGEN
+namespace crypto
+{
+class manager;
+} // namespace crypto
+#endif
 
 /**
  * Represents result of @ref collection#get
@@ -55,10 +62,12 @@ public:
    */
   get_result(couchbase::cas cas,
              codec::encoded_value value,
-             std::optional<std::chrono::system_clock::time_point> expiry_time)
+             std::optional<std::chrono::system_clock::time_point> expiry_time,
+             std::shared_ptr<crypto::manager> crypto_manager = {})
     : result{ cas }
     , value_{ std::move(value) }
     , expiry_time_{ expiry_time }
+    , crypto_manager_{ std::move(crypto_manager) }
   {
   }
 
@@ -79,7 +88,11 @@ public:
            std::enable_if_t<codec::is_transcoder_v<Transcoder>, bool> = true>
   [[nodiscard]] auto content_as() const -> Document
   {
-    return Transcoder::template decode<Document>(value_);
+    if constexpr (codec::is_crypto_transcoder_v<Transcoder>) {
+      return Transcoder::template decode<Document>(value_, crypto_manager_);
+    } else {
+      return Transcoder::template decode<Document>(value_);
+    }
   }
 
   /**
@@ -102,7 +115,11 @@ public:
   template<typename Transcoder, std::enable_if_t<codec::is_transcoder_v<Transcoder>, bool> = true>
   [[nodiscard]] auto content_as() const -> typename Transcoder::document_type
   {
-    return Transcoder::decode(value_);
+    if constexpr (codec::is_crypto_transcoder_v<Transcoder>) {
+      return Transcoder::decode(value_, crypto_manager_);
+    } else {
+      return Transcoder::decode(value_);
+    }
   }
 
   /**
@@ -127,6 +144,7 @@ public:
 private:
   codec::encoded_value value_{};
   std::optional<std::chrono::system_clock::time_point> expiry_time_{};
+  std::shared_ptr<crypto::manager> crypto_manager_{};
 };
 
 } // namespace couchbase

data/ext/couchbase/couchbase/persist_to.hxx

@@ -17,9 +17,11 @@
 
 #pragma once
 
+#include <cstdint>
+
 namespace couchbase
 {
-enum class persist_to {
+enum class persist_to : std::uint8_t {
   /**
    * Do not apply any persistence requirements
    *

data/ext/couchbase/couchbase/replicate_to.hxx

@@ -17,9 +17,11 @@
 
 #pragma once
 
+#include <cstdint>
+
 namespace couchbase
 {
-enum class replicate_to {
+enum class replicate_to : std::uint8_t {
   /**
    * Do not apply any replication requirements.
    *

data/ext/couchbase/couchbase/retry_request.hxx

@@ -27,6 +27,12 @@ namespace couchbase
 class retry_request
 {
 public:
+  retry_request() = default;
+  retry_request(const retry_request&) = default;
+  retry_request(retry_request&&) = default;
+  auto operator=(const retry_request&) -> retry_request& = default;
+  auto operator=(retry_request&&) -> retry_request& = default;
+
   [[nodiscard]] virtual auto retry_attempts() const -> std::size_t = 0;
   [[nodiscard]] virtual auto identifier() const -> std::string = 0;
   [[nodiscard]] virtual auto idempotent() const -> bool = 0;

data/ext/couchbase/couchbase/retry_strategy.hxx

@@ -21,13 +21,17 @@
 #include <couchbase/retry_reason.hxx>
 #include <couchbase/retry_request.hxx>
 
-#include <cstddef>
-
 namespace couchbase
 {
 class retry_strategy
 {
 public:
+  retry_strategy() = default;
+  retry_strategy(const retry_strategy&) = default;
+  retry_strategy(retry_strategy&&) = default;
+  auto operator=(const retry_strategy&) -> retry_strategy& = default;
+  auto operator=(retry_strategy&&) -> retry_strategy& = default;
+
   virtual ~retry_strategy() = default;
   virtual auto retry_after(const retry_request& request, retry_reason reason) -> retry_action = 0;
   [[nodiscard]] virtual auto to_string() const -> std::string = 0;

data/ext/couchbase/couchbase/scan_result_item.hxx

@@ -37,6 +37,13 @@
  */
 namespace couchbase
 {
+#ifndef COUCHBASE_CXX_CLIENT_DOXYGEN
+namespace crypto
+{
+class manager;
+} // namespace crypto
+#endif
+
 class scan_result_item : public result
 {
 public:
@@ -62,12 +69,14 @@ public:
   scan_result_item(std::string id,
                    couchbase::cas cas,
                    codec::encoded_value value,
-                   std::optional<std::chrono::system_clock::time_point> expiry_time)
+                   std::optional<std::chrono::system_clock::time_point> expiry_time,
+                   std::shared_ptr<crypto::manager> crypto_manager = {})
     : result{ cas }
     , id_{ std::move(id) }
     , id_only_{ false }
     , value_{ std::move(value) }
     , expiry_time_{ expiry_time }
+    , crypto_manager_{ std::move(crypto_manager) }
   {
   }
 
@@ -141,7 +150,11 @@ public:
     if (id_only_) {
       return {};
     }
-    return Transcoder::template decode<Document>(value_);
+    if constexpr (codec::is_crypto_transcoder_v<Transcoder>) {
+      return Transcoder::template decode<Document>(value_, crypto_manager_);
+    } else {
+      return Transcoder::template decode<Document>(value_);
+    }
   }
 
   /**
@@ -168,5 +181,6 @@ private:
   bool id_only_{};
   codec::encoded_value value_{};
   std::optional<std::chrono::system_clock::time_point> expiry_time_{};
+  std::shared_ptr<crypto::manager> crypto_manager_{};
 };
 } // namespace couchbase

data/ext/couchbase/couchbase/scope.hxx

@@ -199,14 +199,17 @@ public:
    * @return a manager instance
    *
    * @since 1.0.0
-   * @volatile
+   * @committed
    */
   [[nodiscard]] auto search_indexes() const -> scope_search_index_manager;
 
 private:
   friend class bucket;
 
-  scope(core::cluster core, std::string_view bucket_name, std::string_view name);
+  scope(core::cluster core,
+        std::string_view bucket_name,
+        std::string_view name,
+        std::shared_ptr<crypto::manager> crypto_manager);
 
   std::shared_ptr<scope_impl> impl_;
 };

data/ext/couchbase/couchbase/scope_search_index_manager.hxx

@@ -58,7 +58,7 @@ public:
    * @param handler  handler that implements @ref get_search_index_handler
    *
    * @since 1.0.0
-   * @volatile
+   * @committed
    */
   void get_index(std::string index_name,
                  const get_search_index_options& options,
@@ -74,7 +74,7 @@ public:
    * @param handler  handler that implements @ref get_all_search_indexes_handler
    *
    * @since 1.0.0
-   * @volatile
+   * @committed
    */
   void get_all_indexes(const get_all_search_indexes_options& options,
                        get_all_search_indexes_handler&& handler) const;
@@ -90,7 +90,7 @@ public:
    * @param handler  handler that implements @ref upsert_search_index_handler
    *
    * @since 1.0.0
-   * @volatile
+   * @committed
    */
   void upsert_index(const management::search::index& search_index,
                     const upsert_search_index_options& options,
@@ -108,7 +108,7 @@ public:
    * @param handler  handler that implements @ref drop_search_index_handler
    *
    * @since 1.0.0
-   * @volatile
+   * @committed
    */
   void drop_index(std::string index_name,
                   const drop_search_index_options& options,
@@ -126,7 +126,7 @@ public:
    * @param handler  handler that implements @ref get_indexed_search_index_handler
    *
    * @since 1.0.0
-   * @volatile
+   * @committed
    */
   void get_indexed_documents_count(std::string index_name,
                                    const get_indexed_search_index_options& options,
@@ -145,7 +145,7 @@ public:
    * @param handler  handler that implements @ref pause_ingest_search_index_handler
    *
    * @since 1.0.0
-   * @volatile
+   * @committed
    */
   void pause_ingest(std::string index_name,
                     const pause_ingest_search_index_options& options,
@@ -163,7 +163,7 @@ public:
    * @param handler  handler that implements @ref resume_ingest_search_index_handler
    *
    * @since 1.0.0
-   * @volatile
+   * @committed
    */
   void resume_ingest(std::string index_name,
                      const resume_ingest_search_index_options& options,
@@ -181,7 +181,7 @@ public:
    * @param handler  handler that implements @ref allow_querying_search_index_handler
    *
    * @since 1.0.0
-   * @volatile
+   * @committed
    */
   void allow_querying(std::string index_name,
                       const allow_querying_search_index_options& options,
@@ -199,7 +199,7 @@ public:
    * @param handler  handler that implements @ref disallow_querying_search_index_handler
    *
    * @since 1.0.0
-   * @volatile
+   * @committed
    */
   void disallow_querying(std::string index_name,
                          const disallow_querying_search_index_options& options,
@@ -217,7 +217,7 @@ public:
    * @param handler  handler that implements @ref  freeze_plan_search_index_handler
    *
    * @since 1.0.0
-   * @volatile
+   * @committed
    */
   void freeze_plan(std::string index_name,
                    const freeze_plan_search_index_options& options,
@@ -235,7 +235,7 @@ public:
    * @param handler  handler that implements @ref  unfreeze_plan_search_index_handler
    *
    * @since 1.0.0
-   * @volatile
+   * @committed
    */
   void unfreeze_plan(std::string index_name,
                      const unfreeze_plan_search_index_options& options,
@@ -254,7 +254,7 @@ public:
    * @param handler  handler that implements @ref analyze_document_handler
    *
    * @since 1.0.0
-   * @volatile
+   * @committed
    */
   template<typename Document>
   void analyze_document(std::string index_name,
@@ -292,7 +292,7 @@ public:
    * @param handler  handler that implements @ref analyze_document_handler
    *
    * @since 1.0.0
-   * @volatile
+   * @committed
    */
   void analyze_document(std::string index_name,
                         std::string document,

data/ext/couchbase/couchbase/timeout_options.hxx

@@ -33,6 +33,8 @@ public:
     std::chrono::seconds{ 10 }
   };
   static constexpr std::chrono::milliseconds default_key_value_timeout{ 2'500 };
+  static constexpr std::chrono::milliseconds default_key_value_scan_timeout{ std::chrono::seconds{
+    75 } };
   static constexpr std::chrono::milliseconds default_management_timeout{ std::chrono::seconds{
     75 } };
   static constexpr std::chrono::milliseconds default_query_timeout{ std::chrono::seconds{ 75 } };
@@ -72,6 +74,12 @@ public:
     return *this;
   }
 
+  auto key_value_scan_timeout(std::chrono::milliseconds timeout) -> timeout_options&
+  {
+    key_value_scan_timeout_ = timeout;
+    return *this;
+  }
+
   auto management_timeout(std::chrono::milliseconds timeout) -> timeout_options&
   {
     management_timeout_ = timeout;
@@ -114,6 +122,7 @@ public:
     std::chrono::milliseconds eventing_timeout;
     std::chrono::milliseconds key_value_durable_timeout;
     std::chrono::milliseconds key_value_timeout;
+    std::chrono::milliseconds key_value_scan_timeout;
     std::chrono::milliseconds management_timeout;
     std::chrono::milliseconds query_timeout;
     std::chrono::milliseconds search_timeout;
@@ -125,9 +134,9 @@ public:
   [[nodiscard]] auto build() const -> built
   {
     return {
-      analytics_timeout_, connect_timeout_,    eventing_timeout_, key_value_durable_timeout_,
-      key_value_timeout_, management_timeout_, query_timeout_,    search_timeout_,
-      view_timeout_,      bootstrap_timeout_,  resolve_timeout_,
+      analytics_timeout_, connect_timeout_,        eventing_timeout_,   key_value_durable_timeout_,
+      key_value_timeout_, key_value_scan_timeout_, management_timeout_, query_timeout_,
+      search_timeout_,    view_timeout_,           bootstrap_timeout_,  resolve_timeout_,
     };
   }
 
@@ -137,6 +146,7 @@ private:
   std::chrono::milliseconds eventing_timeout_{ default_eventing_timeout };
   std::chrono::milliseconds key_value_durable_timeout_{ default_key_value_durable_timeout };
   std::chrono::milliseconds key_value_timeout_{ default_key_value_timeout };
+  std::chrono::milliseconds key_value_scan_timeout_{ default_key_value_scan_timeout };
   std::chrono::milliseconds management_timeout_{ default_management_timeout };
   std::chrono::milliseconds query_timeout_{ default_query_timeout };
   std::chrono::milliseconds search_timeout_{ default_search_timeout };

data/ext/couchbase/couchbase/transactions/transaction_get_multi_replicas_from_preferred_server_group_result.hxx

@@ -91,7 +91,10 @@ public:
    */
   [[nodiscard]] auto exists(std::size_t spec_index) const -> bool
   {
-    return spec_index >= content_.size() && content_[spec_index].has_value();
+    if (spec_index >= content_.size()) {
+      throw std::invalid_argument("spec index " + std::to_string(spec_index) + " is not valid");
+    }
+    return content_[spec_index].has_value();
   }
 
 private: