couchbase 4.4.6 → 4.5.1

package/deps/couchbase-cxx-client/core/logger/logger.cxx

@@ -59,6 +59,10 @@ std::shared_ptr<spdlog::logger> file_logger{};
 std::mutex file_logger_mutex;
 std::atomic_int file_logger_version{ 0 };
 
+std::shared_ptr<couchbase::core::logger::log_callback> log_callback{};
+std::mutex log_callback_mutex;
+std::atomic_int log_callback_version{ 0 };
+
 auto
 get_file_logger() -> std::shared_ptr<spdlog::logger>
 {
@@ -72,6 +76,27 @@ get_file_logger() -> std::shared_ptr<spdlog::logger>
   return logger;
 }
 
+auto
+get_custom_callback() -> std::shared_ptr<couchbase::core::logger::log_callback>
+{
+  thread_local std::shared_ptr<couchbase::core::logger::log_callback> callback{ nullptr };
+  thread_local int version{ -1 };
+  if (version != log_callback_version) {
+    const std::scoped_lock lock(log_callback_mutex);
+    callback = log_callback;
+    version = log_callback_version;
+  }
+  return callback;
+}
+
+void
+update_callback_logger(const std::shared_ptr<couchbase::core::logger::log_callback>& new_callback)
+{
+  const std::scoped_lock lock(log_callback_mutex);
+  log_callback = new_callback;
+  ++log_callback_version;
+}
+
 void
 update_file_logger(const std::shared_ptr<spdlog::logger>& new_logger)
 {
@@ -181,6 +206,14 @@ log(const char* file, int line, const char* function, level lvl, std::string_vie
       spdlog::source_loc{ file, line, function }, translate_level(lvl), msg);
   }
 }
+
+void
+log_custom_logger(const char* file, int line, const char* function, level lvl, std::string_view msg)
+{
+  if (auto callback = get_custom_callback()) {
+    (*callback)(msg, lvl, { file, function, line });
+  }
+}
 } // namespace detail
 
 void
@@ -396,6 +429,19 @@ create_console_logger()
   update_file_logger(new_logger);
 }
 
+void
+register_log_callback(log_callback callback)
+{
+  auto new_callback = std::make_shared<log_callback>(std::move(callback));
+  update_callback_logger(new_callback);
+}
+
+void
+unregister_log_callback()
+{
+  update_callback_logger(nullptr);
+}
+
 void
 register_spdlog_logger(const std::shared_ptr<spdlog::logger>& l)
 {

package/deps/couchbase-cxx-client/core/logger/logger.hxx

@@ -25,6 +25,8 @@
 
 #pragma once
 
+#include <functional>
+
 #include "level.hxx"
 
 #include <spdlog/fmt/bundled/core.h>
@@ -36,8 +38,17 @@
 
 namespace couchbase::core::logger
 {
+
 struct configuration;
 
+struct log_location {
+  std::string file;
+  std::string function;
+  int line;
+};
+
+using log_callback = std::function<void(std::string_view, level, log_location)>;
+
 auto
 level_from_str(const std::string& str) -> level;
 
@@ -113,6 +124,12 @@ get() -> spdlog::logger*;
 void
 reset();
 
+void
+register_log_callback(log_callback callback);
+
+void
+unregister_log_callback();
+
 /**
  * Engines that create their own instances of an spdlog::logger should register the logger here to
  * ensure that the verbosity of the logger is updated when memcached receives a request to update
@@ -179,6 +196,13 @@ log(const char* file, int line, const char* function, level lvl, std::string_vie
 
 void
 log_protocol(const char* file, int line, const char* function, std::string_view msg);
+
+void
+log_custom_logger(const char* file,
+                  int line,
+                  const char* function,
+                  level lvl,
+                  std::string_view msg);
 } // namespace detail
 
 /**
@@ -199,6 +223,19 @@ log(const char* file,
   detail::log(file, line, function, lvl, fmt::format(msg, std::forward<Args>(args)...));
 }
 
+template<typename... Args>
+inline void
+log_custom_logger(const char* file,
+                  int line,
+                  const char* function,
+                  level lvl,
+                  fmt::format_string<Args...> msg,
+                  Args&&... args)
+{
+  detail::log_custom_logger(
+    file, line, function, lvl, fmt::format(msg, std::forward<Args>(args)...));
+}
+
 template<typename... Args>
 inline void
 log_protocol(const char* file,
@@ -228,7 +265,6 @@ shutdown();
  */
 auto
 is_initialized() -> bool;
-
 } // namespace couchbase::core::logger
 
 #if defined(__GNUC__) || defined(__clang__)
@@ -243,6 +279,8 @@ is_initialized() -> bool;
  */
 #define COUCHBASE_LOG(file, line, function, severity, ...)                                         \
   do {                                                                                             \
+    couchbase::core::logger::log_custom_logger(file, line, function, severity, __VA_ARGS__);       \
+                                                                                                   \
     if (couchbase::core::logger::should_log(severity)) {                                           \
       couchbase::core::logger::log(file, line, function, severity, __VA_ARGS__);                   \
     }                                                                                              \
@@ -305,6 +343,8 @@ is_initialized() -> bool;
  */
 #define COUCHBASE_LOG_RAW(file, line, function, severity, msg)                                     \
   do {                                                                                             \
+    couchbase::core::logger::log_custom_logger(file, line, function, severity, msg);               \
+                                                                                                   \
     if (couchbase::core::logger::should_log(severity)) {                                           \
       couchbase::core::logger::detail::log(file, line, function, severity, msg);                   \
     }                                                                                              \

package/deps/couchbase-cxx-client/core/management/bucket_settings.hxx

@@ -136,6 +136,7 @@ struct bucket_settings {
   std::optional<bool> history_retention_collection_default{};
   std::optional<std::uint32_t> history_retention_bytes{};
   std::optional<std::uint32_t> history_retention_duration{};
+  std::optional<std::uint16_t> num_vbuckets{};
 
   /**
    * UNCOMMITTED: This API may change in the future

package/deps/couchbase-cxx-client/core/management/bucket_settings_json.hxx

@@ -56,6 +56,10 @@ struct traits<couchbase::core::management::cluster::bucket_settings> {
         history_retention_duration->template as<std::optional<std::uint32_t>>();
     }
 
+    if (auto* num_vbuckets = v.find("numVBuckets"); num_vbuckets != nullptr) {
+      result.num_vbuckets = num_vbuckets->template as<std::optional<std::uint16_t>>();
+    }
+
     if (auto& str = v.at("bucketType").get_string(); str == "couchbase" || str == "membase") {
       result.bucket_type = couchbase::core::management::cluster::bucket_type::couchbase;
     } else if (str == "ephemeral") {

package/deps/couchbase-cxx-client/core/meta/features.hxx

@@ -207,7 +207,39 @@
  */
 #define COUCHBASE_CXX_CLIENT_PUBLIC_API_PARENT_SPAN 1
 
+/**
+ * The library can be configured to use application telemetry (default is enabled)
+ * See couchbase::application_telemetry_options for available options
+ * to pass into couchbase::cluster_options
+ */
+#define COUCHBASE_CXX_CLIENT_SUPPORTS_APP_TELEMETRY 1
+
 /**
  * core API like with_bucket_configuration() yields shared_ptr instead of configuration copy
  */
 #define COUCHBASE_CXX_CLIENT_CORE_RETURNS_POINTER_TO_CONFIG 1
+
+/**
+ * bucket_settings in both the public and core management APIs have a num_vbuckets attribute
+ */
+#define COUCHBASE_CXX_CLIENT_HAS_BUCKET_SETTINGS_NUM_VBUCKETS 1
+
+/**
+ * couchbase::query_options and couchbase::analytics_options provide the methods:
+ *   - add_positional_parameter
+ *   - add_named_parameter
+ *   - clear_positional_parameters
+ *   - clear_named_parameters
+ */
+#define COUCHBASE_CXX_CLIENT_QUERY_OPTIONS_HAVE_ADD_PARAMETER 1
+
+/**
+ * couchbase::query_options and couchbase::analytics_options allow setting both positional and named
+ * parameters.
+ */
+#define COUCHBASE_CXX_CLIENT_QUERY_SUPPORTS_BOTH_POSITIONAL_NAMED_PARAMETERS 1
+
+/**
+ * get_multi API is implemented for transactions
+ */
+#define COUCHBASE_CXX_CLIENT_HAS_TRANSACTIONS_GET_MULTI 1

package/deps/couchbase-cxx-client/core/operations/document_analytics.cxx

@@ -35,16 +35,16 @@ analytics_request::encode_to(analytics_request::encoded_request_type& encoded,
   tao::json::value body{ { "statement", statement },
                          { "client_context_id", encoded.client_context_id },
                          { "timeout", fmt::format("{}ms", encoded.timeout.count()) } };
-  if (positional_parameters.empty()) {
-    for (const auto& [name, value] : named_parameters) {
-      Expects(name.empty() == false);
-      std::string key = name;
-      if (key[0] != '$') {
-        key.insert(key.begin(), '$');
-      }
-      body[key] = utils::json::parse(value);
+
+  for (const auto& [name, value] : named_parameters) {
+    Expects(name.empty() == false);
+    std::string key = name;
+    if (key[0] != '$') {
+      key.insert(key.begin(), '$');
     }
-  } else {
+    body[key] = utils::json::parse(value);
+  }
+  if (!positional_parameters.empty()) {
     std::vector<tao::json::value> parameters;
     parameters.reserve(positional_parameters.size());
     for (const auto& value : positional_parameters) {

package/deps/couchbase-cxx-client/core/operations/document_get_all_replicas.hxx

@@ -131,7 +131,11 @@ struct get_all_replicas_request {
                   }
                 }
                 if (local_handler) {
-                  return local_handler({ std::move(resp.ctx), std::move(ctx->result_) });
+                  if (ctx->result_.empty()) {
+                    // Return an error only when we have no results from any replica.
+                    return local_handler({ std::move(resp.ctx), {} });
+                  }
+                  return local_handler({ {}, std::move(ctx->result_) });
                 }
               });
           } else {
@@ -158,7 +162,11 @@ struct get_all_replicas_request {
                 }
               }
               if (local_handler) {
-                return local_handler({ std::move(resp.ctx), std::move(ctx->result_) });
+                if (ctx->result_.empty()) {
+                  // Return an error only when we have no results from any replica.
+                  return local_handler({ std::move(resp.ctx), {} });
+                }
+                return local_handler({ {}, std::move(ctx->result_) });
               }
             });
           }

package/deps/couchbase-cxx-client/core/operations/document_lookup_in.cxx

@@ -31,6 +31,10 @@ auto
 lookup_in_request::encode_to(lookup_in_request::encoded_request_type& encoded,
                              mcbp_context&& context) -> std::error_code
 {
+  if (specs.empty()) {
+    return errc::common::invalid_argument;
+  }
+
   for (std::size_t i = 0; i < specs.size(); ++i) {
     specs[i].original_index_ = i;
 

package/deps/couchbase-cxx-client/core/operations/document_lookup_in_all_replicas.hxx

@@ -115,6 +115,10 @@ struct lookup_in_all_replicas_request {
               ec = errc::key_value::document_irretrievable;
             }
 
+            if (!ec && specs.empty()) {
+              ec = errc::common::invalid_argument;
+            }
+
             if (ec) {
               return h(response_type{ make_subdocument_error_context(
                 make_key_value_error_context(ec, id), ec, {}, {}, false) });
@@ -183,7 +187,11 @@ struct lookup_in_all_replicas_request {
                       }
                     }
                     if (local_handler) {
-                      return local_handler({ std::move(resp.ctx), std::move(ctx->result_) });
+                      if (ctx->result_.empty()) {
+                        // Return an error only when we have no results from any replica.
+                        return local_handler({ std::move(resp.ctx), {} });
+                      }
+                      return local_handler({ {}, std::move(ctx->result_) });
                     }
                   });
               } else {
@@ -227,7 +235,11 @@ struct lookup_in_all_replicas_request {
                       }
                     }
                     if (local_handler) {
-                      return local_handler({ std::move(resp.ctx), std::move(ctx->result_) });
+                      if (ctx->result_.empty()) {
+                        // Return an error only when we have no results from any replica.
+                        return local_handler({ std::move(resp.ctx), {} });
+                      }
+                      return local_handler({ {}, std::move(ctx->result_) });
                     }
                   });
               }

package/deps/couchbase-cxx-client/core/operations/document_lookup_in_any_replica.hxx

@@ -112,6 +112,10 @@ struct lookup_in_any_replica_request {
               ec = errc::key_value::document_irretrievable;
             }
 
+            if (!ec && specs.empty()) {
+              ec = errc::common::invalid_argument;
+            }
+
             if (ec) {
               return h(response_type{ make_subdocument_error_context(
                 make_key_value_error_context(ec, id), ec, {}, {}, false) });

package/deps/couchbase-cxx-client/core/operations/document_mutate_in.cxx

@@ -36,6 +36,9 @@ mutate_in_request::encode_to(mutate_in_request::encoded_request_type& encoded,
       !context.supports_feature(protocol::hello_feature::subdoc_create_as_deleted)) {
     return errc::common::unsupported_operation;
   }
+  if (specs.empty()) {
+    return errc::common::invalid_argument;
+  }
   for (std::size_t i = 0; i < specs.size(); ++i) {
     auto& entry = specs[i];
     entry.original_index_ = i;
@@ -60,6 +63,7 @@ mutate_in_request::encode_to(mutate_in_request::encoded_request_type& encoded,
   }
   encoded.body().access_deleted(access_deleted);
   encoded.body().create_as_deleted(create_as_deleted);
+  encoded.body().revive_document(revive_document);
   encoded.body().store_semantics(store_semantics);
   encoded.body().specs(specs);
   if (preserve_expiry) {

package/deps/couchbase-cxx-client/core/operations/document_mutate_in.hxx

@@ -63,6 +63,7 @@ struct mutate_in_request {
   couchbase::cas cas{ 0 };
   bool access_deleted{ false };
   bool create_as_deleted{ false };
+  bool revive_document{ false };
   std::optional<std::uint32_t> expiry{};
   couchbase::store_semantics store_semantics{ couchbase::store_semantics::replace };
   std::vector<couchbase::core::impl::subdoc::command> specs{};

package/deps/couchbase-cxx-client/core/operations/document_query.cxx

@@ -64,16 +64,16 @@ query_request::encode_to(query_request::encoded_request_type& encoded,
     timeout_for_service -= std::chrono::milliseconds(500);
   }
   body["timeout"] = fmt::format("{}ms", timeout_for_service.count());
-  if (positional_parameters.empty()) {
-    for (const auto& [name, value] : named_parameters) {
-      Expects(name.empty() == false);
-      std::string key = name;
-      if (key[0] != '$') {
-        key.insert(key.begin(), '$');
-      }
-      body[key] = utils::json::parse(value);
+
+  for (const auto& [name, value] : named_parameters) {
+    Expects(name.empty() == false);
+    std::string key = name;
+    if (key[0] != '$') {
+      key.insert(key.begin(), '$');
     }
-  } else {
+    body[key] = utils::json::parse(value);
+  }
+  if (!positional_parameters.empty()) {
     std::vector<tao::json::value> parameters;
     parameters.reserve(positional_parameters.size());
     for (const auto& value : positional_parameters) {
@@ -237,7 +237,9 @@ query_request::make_response(error_context::query&& ctx,
       response.ctx.ec = errc::common::parsing_failure;
       return response;
     }
-    response.meta.request_id = payload.at("requestID").get_string();
+    if (const auto* i = payload.find("requestID"); i != nullptr) {
+      response.meta.request_id = i->get_string();
+    }
 
     if (const auto* i = payload.find("clientContextID"); i != nullptr) {
       response.meta.client_context_id = i->get_string();

package/deps/couchbase-cxx-client/core/operations/http_noop.cxx

@@ -25,6 +25,7 @@ auto
 http_noop_request::encode_to(http_noop_request::encoded_request_type& encoded,
                              http_context& /* context */) -> std::error_code
 {
+  encoded.type = type;
   encoded.headers["connection"] = "keep-alive";
   encoded.method = "GET";
   encoded.path = "/";

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

@@ -86,6 +86,9 @@ bucket_create_request::encode_to(encoded_request_type& encoded,
   if (bucket.flush_enabled.has_value()) {
     encoded.body.append(fmt::format("&flushEnabled={}", bucket.flush_enabled.value() ? "1" : "0"));
   }
+  if (bucket.num_vbuckets.has_value()) {
+    encoded.body.append(fmt::format("&numVBuckets={}", bucket.num_vbuckets.value()));
+  }
 
   switch (bucket.eviction_policy) {
     case couchbase::core::management::cluster::bucket_eviction_policy::full:

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

@@ -69,6 +69,9 @@ bucket_update_request::encode_to(encoded_request_type& encoded,
   if (bucket.flush_enabled.has_value()) {
     encoded.body.append(fmt::format("&flushEnabled={}", bucket.flush_enabled.value() ? "1" : "0"));
   }
+  if (bucket.num_vbuckets.has_value()) {
+    encoded.body.append(fmt::format("&numVBuckets={}", bucket.num_vbuckets.value()));
+  }
 
   switch (bucket.eviction_policy) {
     case couchbase::core::management::cluster::bucket_eviction_policy::full:

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

@@ -71,9 +71,10 @@ search_index_get_all_request::make_response(error_context::http&& ctx,
         for (const auto& [name, index] : indexes->get_object()) {
           response.indexes.emplace_back(index.as<couchbase::core::management::search::index>());
         }
-        return response;
       }
-    } else if (encoded.status_code == 404) {
+      return response;
+    }
+    if (encoded.status_code == 404) {
       tao::json::value payload{};
       try {
         payload = utils::json::parse(encoded.body.data());

package/deps/couchbase-cxx-client/core/origin.cxx

@@ -25,6 +25,8 @@
 #include <spdlog/fmt/bundled/core.h>
 
 #include <tao/json.hpp>
+
+#include <random>
 #include <utility>
 
 namespace tao::json
@@ -298,11 +300,6 @@ origin::to_json() const -> std::string
   return tao::json::to_string(json);
 }
 
-auto
-cluster_credentials::uses_certificate() const -> bool
-{
-  return !certificate_path.empty();
-}
 } // namespace couchbase::core
 
 couchbase::core::origin::origin(const couchbase::core::origin& other)
@@ -343,6 +340,7 @@ couchbase::core::origin::origin(couchbase::core::cluster_credentials auth,
                                 const couchbase::core::utils::connection_string& connstr)
   : options_(connstr.options)
   , credentials_(std::move(auth))
+  , connection_string_(connstr.input)
 {
   nodes_.reserve(connstr.bootstrap_nodes.size());
   for (const auto& node : connstr.bootstrap_nodes) {
@@ -350,6 +348,9 @@ couchbase::core::origin::origin(couchbase::core::cluster_credentials auth,
                         node.port > 0 ? std::to_string(node.port)
                                       : std::to_string(connstr.default_port));
   }
+  if (!options_.preserve_bootstrap_nodes_order) {
+    shuffle_nodes();
+  }
   next_node_ = nodes_.begin();
 }
 auto
@@ -365,6 +366,11 @@ couchbase::core::origin::operator=(const couchbase::core::origin& other) -> couc
   return *this;
 }
 auto
+couchbase::core::origin::connection_string() const -> const std::string&
+{
+  return connection_string_;
+}
+auto
 couchbase::core::origin::username() const -> const std::string&
 {
   return credentials_.username;
@@ -404,10 +410,21 @@ couchbase::core::origin::get_nodes() const -> std::vector<std::string>
   }
   return res;
 }
+
+void
+couchbase::core::origin::shuffle_nodes()
+{
+  static thread_local std::default_random_engine gen{ std::random_device{}() };
+  std::shuffle(nodes_.begin(), nodes_.end(), gen);
+}
+
 void
 couchbase::core::origin::set_nodes(couchbase::core::origin::node_list nodes)
 {
   nodes_ = std::move(nodes);
+  if (!options_.preserve_bootstrap_nodes_order) {
+    shuffle_nodes();
+  }
   next_node_ = nodes_.begin();
   exhausted_ = false;
 }
@@ -433,6 +450,9 @@ couchbase::core::origin::set_nodes_from_config(const topology::configuration& co
         std::make_pair(node.hostname_for(options_.network), std::to_string(port)));
     }
   }
+  if (!options_.preserve_bootstrap_nodes_order) {
+    shuffle_nodes();
+  }
   next_node_ = nodes_.begin();
 }
 auto

package/deps/couchbase-cxx-client/core/origin.hxx

@@ -17,6 +17,7 @@
 
 #pragma once
 
+#include "cluster_credentials.hxx"
 #include "cluster_options.hxx"
 
 #include <string>
@@ -30,20 +31,10 @@ namespace utils
 struct connection_string;
 } // namespace utils
 
-struct cluster_credentials {
-  std::string username{};
-  std::string password{};
-  std::string certificate_path{};
-  std::string key_path{};
-  std::optional<std::vector<std::string>> allowed_sasl_mechanisms{};
-
-  [[nodiscard]] bool uses_certificate() const;
-};
-
 namespace topology
 {
 struct configuration;
-}
+} // namespace topology
 
 struct origin {
   using node_entry = std::pair<std::string, std::string>;
@@ -64,29 +55,31 @@ struct origin {
          const std::string& port,
          cluster_options options);
   origin(cluster_credentials auth, const utils::connection_string& connstr);
-  origin& operator=(origin&& other) = default;
-  origin& operator=(const origin& other);
+  auto operator=(origin&& other) -> origin& = default;
+  auto operator=(const origin& other) -> origin&;
 
-  [[nodiscard]] const std::string& username() const;
-  [[nodiscard]] const std::string& password() const;
-  [[nodiscard]] const std::string& certificate_path() const;
-  [[nodiscard]] const std::string& key_path() const;
+  [[nodiscard]] auto connection_string() const -> const std::string&;
+  [[nodiscard]] auto username() const -> const std::string&;
+  [[nodiscard]] auto password() const -> const std::string&;
+  [[nodiscard]] auto certificate_path() const -> const std::string&;
+  [[nodiscard]] auto key_path() const -> const std::string&;
 
-  [[nodiscard]] std::vector<std::string> get_hostnames() const;
-  [[nodiscard]] std::vector<std::string> get_nodes() const;
+  [[nodiscard]] auto get_hostnames() const -> std::vector<std::string>;
+  [[nodiscard]] auto get_nodes() const -> std::vector<std::string>;
 
+  void shuffle_nodes();
   void set_nodes(node_list nodes);
   void set_nodes_from_config(const topology::configuration& config);
 
-  [[nodiscard]] std::pair<std::string, std::string> next_address();
+  [[nodiscard]] auto next_address() -> std::pair<std::string, std::string>;
 
-  [[nodiscard]] bool exhausted() const;
+  [[nodiscard]] auto exhausted() const -> bool;
 
   void restart();
 
-  [[nodiscard]] const couchbase::core::cluster_options& options() const;
-  [[nodiscard]] couchbase::core::cluster_options& options();
-  [[nodiscard]] const couchbase::core::cluster_credentials& credentials() const;
+  [[nodiscard]] auto options() const -> const couchbase::core::cluster_options&;
+  [[nodiscard]] auto options() -> couchbase::core::cluster_options&;
+  [[nodiscard]] auto credentials() const -> const couchbase::core::cluster_credentials&;
   [[nodiscard]] auto to_json() const -> std::string;
 
 private:
@@ -95,6 +88,7 @@ private:
   node_list nodes_{};
   node_list::iterator next_node_{};
   bool exhausted_{ false };
+  std::string connection_string_{};
 };
 
 } // namespace couchbase::core

package/deps/couchbase-cxx-client/core/platform/random.cc

@@ -82,9 +82,12 @@ public:
 #ifdef WIN32
     return CryptGenRandom(handle, (DWORD)size, static_cast<BYTE*>(dest));
 #else
-    // TODO(CXXCBC-549)
-    // NOLINTNEXTLINE(clang-analyzer-unix.BlockInCriticalSection)
-    return static_cast<std::size_t>(read(handle, dest, size)) == size;
+#if defined(__clang__) && defined(__clang_analyzer__)
+    [[clang::suppress]]
+#endif
+      // TODO(CXXCBC-549)
+      // NOLINTNEXTLINE(clang-analyzer-unix.BlockInCriticalSection)
+      return static_cast<std::size_t>(read(handle, dest, size)) == size;
 #endif
   }
 

package/deps/couchbase-cxx-client/core/platform/random.h

@@ -32,8 +32,8 @@ class RandomGenerator
 public:
   RandomGenerator();
 
-  std::uint64_t next();
+  auto next() -> std::uint64_t;
 
-  static bool getBytes(void* dest, size_t size);
+  static auto getBytes(void* dest, size_t size) -> bool;
 };
 } // namespace couchbase::core

package/deps/couchbase-cxx-client/core/protocol/cmd_mutate_in.hxx

@@ -151,6 +151,15 @@ public:
     }
   }
 
+  void revive_document(bool value)
+  {
+    if (value) {
+      flags_ |= doc_flag_revive_document;
+    } else {
+      flags_ &= ~doc_flag_revive_document;
+    }
+  }
+
   void store_semantics(couchbase::store_semantics semantics)
   {
     flags_ &= std::byte{ 0b1111'1100U }; /* reset first two bits */