couchbase 4.4.1 → 4.4.3

package/deps/couchbase-cxx-client/core/transactions/attempt_context_impl.cxx

@@ -2975,7 +2975,7 @@ attempt_context_impl::do_get(const core::document_id& id,
            allow_replica,
            resolving_missing_atr_entry = std::move(resolving_missing_atr_entry),
            cb = std::move(cb)](std::optional<error_class> ec,
-                               std::optional<std::string> err_message,
+                               const std::optional<std::string>& err_message,
                                std::optional<transaction_get_result> doc) mutable {
             if (!ec && !doc) {
               // it just isn't there.
@@ -3101,20 +3101,21 @@ template<typename LookupInRequest, typename Callback>
 void
 execute_lookup(attempt_context_impl* ctx, LookupInRequest& req, Callback&& cb)
 {
-  ctx->overall()->cluster_ref().execute(req, [ctx, cb = std::forward<Callback>(cb)](auto resp) {
-    auto ec = error_class_from_response(resp);
-    if (ec) {
-      CB_ATTEMPT_CTX_LOG_TRACE(ctx, "get_doc got error {} : {}", resp.ctx.ec().message(), *ec);
-      switch (*ec) {
-        case FAIL_PATH_NOT_FOUND:
-          return cb(ec, resp.ctx.ec().message(), transaction_get_result::create_from(resp));
-        default:
-          return cb(ec, resp.ctx.ec().message(), std::nullopt);
+  ctx->overall()->cluster_ref().execute(
+    req, [ctx, cb = std::forward<Callback>(cb)](const auto& resp) {
+      auto ec = error_class_from_response(resp);
+      if (ec) {
+        CB_ATTEMPT_CTX_LOG_TRACE(ctx, "get_doc got error {} : {}", resp.ctx.ec().message(), *ec);
+        switch (*ec) {
+          case FAIL_PATH_NOT_FOUND:
+            return cb(ec, resp.ctx.ec().message(), transaction_get_result::create_from(resp));
+          default:
+            return cb(ec, resp.ctx.ec().message(), std::nullopt);
+        }
+      } else {
+        return cb({}, {}, transaction_get_result::create_from(resp));
       }
-    } else {
-      return cb({}, {}, transaction_get_result::create_from(resp));
-    }
-  });
+    });
 }
 } // namespace
 
@@ -3161,7 +3162,7 @@ attempt_context_impl::get_doc(const core::document_id& id,
 template<typename Handler, typename Delay>
 void
 attempt_context_impl::create_staged_insert_error_handler(const core::document_id& id,
-                                                         codec::encoded_value content,
+                                                         const codec::encoded_value& content,
                                                          std::uint64_t cas,
                                                          Delay&& delay,
                                                          const std::string& op_id,

package/deps/couchbase-cxx-client/core/transactions/attempt_context_impl.hxx

@@ -463,8 +463,8 @@ private:
 
   template<typename Handler, typename Delay>
   void create_staged_insert_error_handler(const core::document_id& id,
-                                          codec::encoded_value content,
-                                          uint64_t cas,
+                                          const codec::encoded_value& content,
+                                          std::uint64_t cas,
                                           Delay&& delay,
                                           const std::string& op_id,
                                           Handler&& cb,

package/deps/couchbase-cxx-client/core/transactions/staged_mutation.cxx

@@ -568,7 +568,7 @@ staged_mutation_queue::commit_doc(const std::shared_ptr<attempt_context_impl>& c
                   res,
                   item,
                   [ambiguity_resolution_mode, cas_zero_mode, handler = std::move(handler)](
-                    auto e) mutable {
+                    const auto& e) mutable {
                     if (e) {
                       return handler(e, ambiguity_resolution_mode, cas_zero_mode);
                     }
@@ -610,7 +610,7 @@ staged_mutation_queue::commit_doc(const std::shared_ptr<attempt_context_impl>& c
                 res,
                 item,
                 [ambiguity_resolution_mode, cas_zero_mode, handler = std::move(handler)](
-                  auto e) mutable {
+                  const auto& e) mutable {
                   if (e) {
                     return handler(e, ambiguity_resolution_mode, cas_zero_mode);
                   }

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

@@ -99,7 +99,7 @@ transactions::create(core::cluster cluster,
 {
   auto barrier =
     std::make_shared<std::promise<std::pair<std::error_code, std::shared_ptr<transactions>>>>();
-  create(std::move(cluster), config, [barrier](auto ec, auto txns) mutable {
+  create(std::move(cluster), config, [barrier](auto ec, const auto& txns) mutable {
     barrier->set_value({ ec, txns });
   });
   return barrier->get_future();
@@ -171,7 +171,7 @@ wrap_public_api_run(transactions& txns,
                     std::size_t max_attempts,
                     Handler&& fn) -> ::couchbase::transactions::transaction_result
 {
-  return wrap_run(txns, config, max_attempts, [fn = std::forward<Handler>(fn)](auto ctx) {
+  return wrap_run(txns, config, max_attempts, [fn = std::forward<Handler>(fn)](const auto& ctx) {
     const couchbase::error err = fn(ctx);
     if (err && err.ec() != errc::transaction_op::transaction_op_failed) {
       if (err.ec().category() == core::impl::transaction_op_category()) {

package/deps/couchbase-cxx-client/core/utils/connection_string.cxx

@@ -34,7 +34,7 @@ using namespace tao::pegtl;
 
 struct bucket_name : seq<uri::segment_nz> {
 };
-using param_key = star<sor<abnf::ALPHA, abnf::DIGIT, one<'_'>>>;
+using param_key = star<sor<abnf::ALPHA, abnf::DIGIT, one<'_', '.'>>>;
 using param_value = star<sor<minus<uri::pchar, one<'=', '&', '?'>>, one<'/'>>>;
 struct param : seq<param_key, one<'='>, param_value> {
 };
@@ -237,38 +237,69 @@ parse_option(bool& receiver,
 }
 
 void
-parse_option(tls_verify_mode& receiver,
+parse_option(io::ip_protocol& receiver,
              const std::string& name,
              const std::string& value,
              std::vector<std::string>& warnings)
 {
-  if (value == "none") {
-    receiver = tls_verify_mode::none;
-  } else if (value == "peer") {
-    receiver = tls_verify_mode::peer;
+  if (value == "any") {
+    receiver = io::ip_protocol::any;
+  } else if (value == "force_ipv4") {
+    receiver = io::ip_protocol::force_ipv4;
+  } else if (value == "force_ipv6") {
+    receiver = io::ip_protocol::force_ipv6;
   } else {
     warnings.push_back(fmt::format(
-      R"(unable to parse "{}" parameter in connection string (value "{}" is not a valid TLS verification mode))",
+      R"(unable to parse "{}" parameter in connection string (value "{}" is not a valid IP protocol preference))",
       name,
       value));
   }
 }
 
+#ifdef COUCHBASE_CXX_CLIENT_COLUMNAR
 void
-parse_option(io::ip_protocol& receiver,
+parse_option(std::chrono::milliseconds& receiver,
              const std::string& name,
              const std::string& value,
              std::vector<std::string>& warnings)
 {
-  if (value == "any") {
-    receiver = io::ip_protocol::any;
-  } else if (value == "force_ipv4") {
-    receiver = io::ip_protocol::force_ipv4;
-  } else if (value == "force_ipv6") {
-    receiver = io::ip_protocol::force_ipv6;
+  try {
+    receiver = std::chrono::duration_cast<std::chrono::milliseconds>(
+      parse_duration(string_codec::url_decode(value)));
+  } catch (const duration_parse_error& dpe) {
+    warnings.push_back(
+      fmt::format(R"(unable to parse "{}" parameter in connection string (value: "{}"): {})",
+                  name,
+                  value,
+                  dpe.what()));
+  } catch (const std::invalid_argument& ex1) {
+    warnings.push_back(fmt::format(
+      R"(unable to parse "{}" parameter in connection string (value "{}" is not a number): {})",
+      name,
+      value,
+      ex1.what()));
+  } catch (const std::out_of_range& ex2) {
+    warnings.push_back(fmt::format(
+      R"(unable to parse "{}" parameter in connection string (value "{}" is out of range): {})",
+      name,
+      value,
+      ex2.what()));
+  }
+}
+#else
+void
+parse_option(tls_verify_mode& receiver,
+             const std::string& name,
+             const std::string& value,
+             std::vector<std::string>& warnings)
+{
+  if (value == "none") {
+    receiver = tls_verify_mode::none;
+  } else if (value == "peer") {
+    receiver = tls_verify_mode::peer;
   } else {
     warnings.push_back(fmt::format(
-      R"(unable to parse "{}" parameter in connection string (value "{}" is not a valid IP protocol preference))",
+      R"(unable to parse "{}" parameter in connection string (value "{}" is not a valid TLS verification mode))",
       name,
       value));
   }
@@ -323,6 +354,7 @@ parse_option(std::chrono::milliseconds& receiver,
     }
   }
 }
+#endif
 
 void
 extract_options(connection_string& connstr)
@@ -333,6 +365,54 @@ extract_options(connection_string& connstr)
     connstr.options.enable_dns_srv = false;
   }
   for (const auto& [name, value] : connstr.params) {
+#ifdef COUCHBASE_CXX_CLIENT_COLUMNAR
+    if (name == "security.trust_only_pem_file") {
+      /**
+       * Set the trust cert path
+       */
+      parse_option(connstr.options.trust_certificate, name, value, connstr.warnings);
+    } else if (name == "security.disable_server_certificate_verification") {
+      /**
+       * Disable TLS server cert verification if set to true.
+       */
+      if (value == "true" || value == "yes" || value == "on" || value == "1") {
+        connstr.options.tls_verify = tls_verify_mode::none;
+      } else if (value == "false" || value == "no" || value == "off" || value == "0") {
+        connstr.options.tls_verify = tls_verify_mode::peer;
+      } else {
+        connstr.warnings.push_back(fmt::format(
+          R"(unable to parse "{}" parameter in connection string (value "{}" cannot be interpreted as a boolean))",
+          name,
+          value));
+      }
+
+    } else if (name == "timeout.connect_timeout") {
+      /**
+       * The period of time allocated to complete bootstrap
+       */
+      parse_option(connstr.options.bootstrap_timeout, name, value, connstr.warnings);
+    } else if (name == "timeout.dispatch_timeout") {
+      /**
+       * Number of seconds to wait before timing out a Query or N1QL request by the client.
+       */
+      parse_option(connstr.options.dispatch_timeout, name, value, connstr.warnings);
+    } else if (name == "timeout.query_timeout") {
+      /**
+       * Number of seconds to wait before timing out a Query or N1QL request by the client.
+       */
+      parse_option(connstr.options.query_timeout, name, value, connstr.warnings);
+    } else if (name == "timeout.resolve_timeout") {
+      /**
+       * The period of time to resolve DNS name of the node to IP address
+       */
+      parse_option(connstr.options.resolve_timeout, name, value, connstr.warnings);
+    } else if (name == "timeout.socket_connect_timeout") {
+      /**
+       * Number of seconds the client should wait while attempting to connect to a node’s KV service
+       * via a socket. Initial connection, reconnecting, node added, etc.
+       */
+      parse_option(connstr.options.connect_timeout, name, value, connstr.warnings);
+#else
     if (name == "kv_connect_timeout") {
       /**
        * Number of seconds the client should wait while attempting to connect to a node’s KV service
@@ -404,6 +484,7 @@ extract_options(connection_string& connstr)
       if (force_ipv4) {
         connstr.options.use_ip_protocol = io::ip_protocol::force_ipv4;
       }
+#endif
     } else if (name == "ip_protocol") {
       /**
        * Controls preference of IP protocol for name resolution
@@ -413,6 +494,37 @@ extract_options(connection_string& connstr)
       parse_option(connstr.options.config_poll_interval, name, value, connstr.warnings);
     } else if (name == "config_poll_floor") {
       parse_option(connstr.options.config_poll_floor, name, value, connstr.warnings);
+    } else if (name == "enable_dns_srv") {
+      if (connstr.bootstrap_nodes.size() == 1) {
+        parse_option(connstr.options.enable_dns_srv, name, value, connstr.warnings);
+      } else {
+        connstr.warnings.push_back(fmt::format(
+          R"(parameter "{}" requires single entry in bootstrap nodes list of the connection string, ignoring (value "{}"))",
+          name,
+          value));
+      }
+    } else if (name == "network") {
+      connstr.options.network =
+        value; /* current known values are "auto", "default" and "external" */
+    } else if (name == "user_agent_extra") {
+      /**
+       * string, that will be appended to identification fields of the server protocols (key in HELO
+       * packet for MCBP, "user-agent" header for HTTP)
+       */
+      parse_option(connstr.options.user_agent_extra, name, value, connstr.warnings);
+    } else if (name == "dump_configuration") {
+      /**
+       * Whether to dump every new configuration on TRACE level
+       */
+      parse_option(connstr.options.dump_configuration, name, value, connstr.warnings);
+    } else if (name == "enable_clustermap_notification") {
+      /**
+       * Allow the server to push configuration updates asynchronously.
+       */
+      parse_option(connstr.options.enable_clustermap_notification, name, value, connstr.warnings);
+    } else if (name == "disable_mozilla_ca_certificates") {
+      parse_option(connstr.options.disable_mozilla_ca_certificates, name, value, connstr.warnings);
+#ifndef COUCHBASE_CXX_CLIENT_COLUMNAR
     } else if (name == "max_http_connections") {
       /**
        * The maximum number of HTTP connections allowed on a per-host and per-port basis.  0
@@ -429,40 +541,16 @@ extract_options(connection_string& connstr)
        * The period of time allocated to complete bootstrap
        */
       parse_option(connstr.options.bootstrap_timeout, name, value, connstr.warnings);
-#ifdef COUCHBASE_CXX_CLIENT_COLUMNAR
-    } else if (name == "dispatch_timeout") {
-      /**
-       * The period of time allocated to complete HTTP session bootstrap
-       */
-      parse_option(connstr.options.dispatch_timeout, name, value, connstr.warnings);
-#endif
     } else if (name == "resolve_timeout") {
       /**
        * The period of time to resolve DNS name of the node to IP address
        */
       parse_option(connstr.options.resolve_timeout, name, value, connstr.warnings);
-    } else if (name == "enable_dns_srv") {
-      if (connstr.bootstrap_nodes.size() == 1) {
-        parse_option(connstr.options.enable_dns_srv, name, value, connstr.warnings);
-      } else {
-        connstr.warnings.push_back(fmt::format(
-          R"(parameter "{}" requires single entry in bootstrap nodes list of the connection string, ignoring (value "{}"))",
-          name,
-          value));
-      }
-    } else if (name == "network") {
-      connstr.options.network =
-        value; /* current known values are "auto", "default" and "external" */
     } else if (name == "show_queries") {
       /**
        * Whether to display N1QL, Analytics, Search queries on info level (default false)
        */
       parse_option(connstr.options.show_queries, name, value, connstr.warnings);
-    } else if (name == "enable_clustermap_notification") {
-      /**
-       * Allow the server to push configuration updates asynchronously.
-       */
-      parse_option(connstr.options.enable_clustermap_notification, name, value, connstr.warnings);
     } else if (name == "enable_unordered_execution") {
       /**
        * Allow the server to reorder commands
@@ -487,25 +575,13 @@ extract_options(connection_string& connstr)
       parse_option(connstr.options.enable_metrics, name, value, connstr.warnings);
     } else if (name == "tls_verify") {
       parse_option(connstr.options.tls_verify, name, value, connstr.warnings);
-    } else if (name == "disable_mozilla_ca_certificates") {
-      parse_option(connstr.options.disable_mozilla_ca_certificates, name, value, connstr.warnings);
     } else if (name == "tls_disable_deprecated_protocols") {
       parse_option(connstr.options.tls_disable_deprecated_protocols, name, value, connstr.warnings);
     } else if (name == "tls_disable_v1_2") {
       parse_option(connstr.options.tls_disable_v1_2, name, value, connstr.warnings);
-    } else if (name == "user_agent_extra") {
-      /**
-       * string, that will be appended to identification fields of the server protocols (key in HELO
-       * packet for MCBP, "user-agent" header for HTTP)
-       */
-      parse_option(connstr.options.user_agent_extra, name, value, connstr.warnings);
-    } else if (name == "dump_configuration") {
-      /**
-       * Whether to dump every new configuration on TRACE level
-       */
-      parse_option(connstr.options.dump_configuration, name, value, connstr.warnings);
     } else if (name == "server_group") {
       parse_option(connstr.options.server_group, name, value, connstr.warnings);
+#endif
     } else {
       connstr.warnings.push_back(
         fmt::format(R"(unknown parameter "{}" in connection string (value "{}"))", name, value));

package/deps/couchbase-cxx-client/core/utils/movable_function.hxx

@@ -18,7 +18,6 @@
 #pragma once
 
 #include <functional>
-#include <gsl/assert>
 #include <memory>
 
 /* replace with standard version once http://wg21.link/P0288 will be accepted and implemented */

package/deps/couchbase-cxx-client/couchbase/analytics_meta_data.hxx

@@ -20,10 +20,11 @@
 #include <couchbase/analytics_metrics.hxx>
 #include <couchbase/analytics_status.hxx>
 #include <couchbase/analytics_warning.hxx>
-#include <couchbase/codec/json_transcoder.hxx>
+#include <couchbase/codec/encoded_value.hxx>
 
 #include <cinttypes>
 #include <optional>
+#include <string>
 #include <vector>
 
 namespace couchbase

package/deps/couchbase-cxx-client/couchbase/analytics_options.hxx

@@ -19,18 +19,23 @@
 
 #include <couchbase/analytics_result.hxx>
 #include <couchbase/analytics_scan_consistency.hxx>
-#include <couchbase/codec/tao_json_serializer.hxx>
 #include <couchbase/common_options.hxx>
 #include <couchbase/error.hxx>
 #include <couchbase/mutation_state.hxx>
 
 #include <chrono>
 #include <functional>
-#include <memory>
+#include <map>
 #include <optional>
 
 namespace couchbase
 {
+
+namespace codec
+{
+class tao_json_serializer;
+} // namespace codec
+
 /**
  * Options for cluster#analytics_query() and scope#analytics_query().
  *
@@ -223,7 +228,6 @@ struct analytics_options : public common_options<analytics_options> {
   }
 
   /**
-   *
    * @tparam Value
    * @param name
    * @param value
@@ -232,10 +236,12 @@ struct analytics_options : public common_options<analytics_options> {
    * @since 1.0.0
    * @committed
    */
-  template<typename Value>
+  template<typename Serializer = codec::tao_json_serializer,
+           typename Value,
+           std::enable_if_t<codec::is_serializer_v<Serializer>, bool> = true>
   auto raw(std::string name, const Value& value) -> analytics_options&
   {
-    raw_[std::move(name)] = std::move(codec::tao_json_serializer::serialize(value));
+    raw_[std::move(name)] = std::move(Serializer::template serialize<const Value&>(value));
     return self();
   }
 
@@ -249,12 +255,14 @@ struct analytics_options : public common_options<analytics_options> {
    * @since 1.0.0
    * @committed
    */
-  template<typename... Parameters>
+  template<typename Serializer = codec::tao_json_serializer,
+           typename... Parameters,
+           std::enable_if_t<codec::is_serializer_v<Serializer>, bool> = true>
   auto positional_parameters(const Parameters&... parameters) -> analytics_options&
   {
     named_parameters_.clear();
     positional_parameters_.clear();
-    encode_positional_parameters(parameters...);
+    encode_positional_parameters<Serializer>(parameters...);
     return self();
   }
 
@@ -268,12 +276,14 @@ struct analytics_options : public common_options<analytics_options> {
    * @since 1.0.0
    * @committed
    */
-  template<typename... Parameters>
+  template<typename Serializer = codec::tao_json_serializer,
+           typename... Parameters,
+           std::enable_if_t<codec::is_serializer_v<Serializer>, bool> = true>
   auto named_parameters(const Parameters&... parameters) -> analytics_options&
   {
     named_parameters_.clear();
     positional_parameters_.clear();
-    encode_named_parameters(parameters...);
+    encode_named_parameters<Serializer>(parameters...);
     return self();
   }
 
@@ -343,23 +353,30 @@ struct analytics_options : public common_options<analytics_options> {
   }
 
 private:
-  template<typename Parameter, typename... Rest>
+  template<typename Serializer = codec::tao_json_serializer,
+           typename Parameter,
+           typename... Rest,
+           std::enable_if_t<codec::is_serializer_v<Serializer>, bool> = true>
   void encode_positional_parameters(const Parameter& parameter, Rest... args)
   {
     positional_parameters_.emplace_back(
-      std::move(codec::tao_json_serializer::serialize(parameter)));
+      std::move(Serializer::template serialize<Parameter>(parameter)));
     if constexpr (sizeof...(args) > 0) {
-      encode_positional_parameters(args...);
+      encode_positional_parameters<Serializer>(args...);
     }
   }
 
-  template<typename Name, typename Parameter, typename... Rest>
+  template<typename Serializer = codec::tao_json_serializer,
+           typename Name,
+           typename Parameter,
+           typename... Rest,
+           std::enable_if_t<codec::is_serializer_v<Serializer>, bool> = true>
   void encode_named_parameters(const std::pair<Name, Parameter>& parameter, Rest... args)
   {
     named_parameters_[parameter.first] =
-      std::move(codec::tao_json_serializer::serialize(parameter.second));
+      std::move(Serializer::template serialize<Parameter>(parameter.second));
     if constexpr (sizeof...(args) > 0) {
-      encode_named_parameters(args...);
+      encode_named_parameters<Serializer>(args...);
     }
   }
 

package/deps/couchbase-cxx-client/couchbase/analytics_result.hxx

@@ -18,15 +18,18 @@
 #pragma once
 
 #include <couchbase/analytics_meta_data.hxx>
-#include <couchbase/codec/tao_json_serializer.hxx>
+#include <couchbase/codec/encoded_value.hxx>
+#include <couchbase/codec/serializer_traits.hxx>
 
-#include <chrono>
 #include <cinttypes>
-#include <optional>
 #include <vector>
 
 namespace couchbase
 {
+namespace codec
+{
+class tao_json_serializer;
+} // namespace codec
 
 /**
  * Represents result of @ref cluster#analytics_query() and @ref scope#analytics_query() calls.
@@ -78,7 +81,7 @@ public:
     return rows_;
   }
 
-  template<typename Serializer,
+  template<typename Serializer = codec::tao_json_serializer,
            typename Document = typename Serializer::document_type,
            std::enable_if_t<codec::is_serializer_v<Serializer>, bool> = true>
   [[nodiscard]] auto rows_as() const -> std::vector<Document>
@@ -91,11 +94,6 @@ public:
     return rows;
   }
 
-  [[nodiscard]] auto rows_as_json() const -> std::vector<codec::tao_json_serializer::document_type>
-  {
-    return rows_as<codec::tao_json_serializer>();
-  }
-
 private:
   analytics_meta_data meta_data_{};
   std::vector<codec::binary> rows_{};

package/deps/couchbase-cxx-client/couchbase/behavior_options.hxx

@@ -60,16 +60,7 @@ public:
     return *this;
   }
 
-  /**
-   * Selects network to use.
-   *
-   * @param name network name as it is exposed in the configuration.
-   * @return this object for chaining purposes.
-   *
-   * @see
-   * https://docs.couchbase.com/server/current/learn/clusters-and-availability/connectivity.html#alternate-addresses
-   * @see https://docs.couchbase.com/server/current/rest-api/rest-set-up-alternate-address.html
-   */
+  [[deprecated("Use couchbase::network_options#preferred_network() instead.")]]
   auto network(std::string name) -> behavior_options&
   {
     network_ = std::move(name);

package/deps/couchbase-cxx-client/couchbase/boolean_query.hxx

@@ -51,7 +51,7 @@ namespace couchbase
  * > 5`.
  * * and finally, exclude documents with `city` `"Padfield"` or `"Gilingham"`.
  *
- * @snippet test_unit_search.cxx search-boolean
+ * @snippet{trimleft} test_unit_search.cxx search-boolean
  *
  * @see https://docs.couchbase.com/server/current/fts/fts-supported-queries-boolean-field-query.html
  * server documentation

package/deps/couchbase-cxx-client/couchbase/codec/codec_flags.hxx

@@ -18,7 +18,6 @@
 #pragma once
 
 #include <cinttypes>
-#include <vector>
 
 namespace couchbase::codec::codec_flags
 {

package/deps/couchbase-cxx-client/couchbase/codec/default_json_transcoder.hxx

@@ -18,13 +18,13 @@
 #pragma once
 
 #include <couchbase/codec/json_transcoder.hxx>
-#include <couchbase/codec/tao_json_serializer.hxx>
 #include <couchbase/codec/transcoder_traits.hxx>
 
 namespace couchbase
 {
 namespace codec
 {
+class tao_json_serializer;
 using default_json_transcoder = json_transcoder<tao_json_serializer>;
 
 #ifndef COUCHBASE_CXX_CLIENT_DOXYGEN

package/deps/couchbase-cxx-client/couchbase/codec/tao_json_serializer.hxx

@@ -47,7 +47,7 @@ public:
   static auto serialize([[maybe_unused]] Document document) -> binary
   {
     try {
-      if constexpr (std::is_null_pointer_v<Document>) {
+      if constexpr (std::is_null_pointer_v<std::remove_reference_t<Document>>) {
         return core::utils::json::generate_binary(tao::json::null);
       } else {
         return core::utils::json::generate_binary(tao::json::value(document));

package/deps/couchbase-cxx-client/couchbase/collection.hxx

@@ -348,6 +348,13 @@ public:
    * @param options the custom options
    * @return the future object with first available result, might be the active or a replica.
    *
+   * Select preferred server group in connection options:
+   * @snippet{trimleft} test_integration_read_replica.cxx select-preferred_server_group
+   *
+   * Restrict get_any_replica to reach nodes that belong to selected server
+   * group only:
+   * @snippet{trimleft} test_integration_read_replica.cxx get_any_replica-with-read_preference
+   *
    * @exception errc::key_value::document_irretrievable
    *    the situation where the SDK got all responses (most likely: key not found) but none of them
    * were successful so it ended up not returning anything
@@ -388,6 +395,13 @@ public:
    * @note Individual errors are ignored, so you can think of this API as a best effort
    * approach which explicitly emphasises availability over consistency.
    *
+   * Select preferred server group in connection options:
+   * @snippet{trimleft} test_integration_read_replica.cxx select-preferred_server_group
+   *
+   * Restrict get_all_replicas to reach nodes that belong to selected server
+   * group only:
+   * @snippet{trimleft} test_integration_read_replica.cxx get_all_replicas-with-read_preference
+   *
    * @param document_id the document id which is used to uniquely identify it.
    * @param options the custom options
    * @return future object that carries result of the operation

package/deps/couchbase-cxx-client/couchbase/conjunction_query.hxx

@@ -32,7 +32,7 @@ namespace couchbase
  *
  * Match documents with `"location"` in the field `reviews.content` and `true` in the field
  * `free_breakfast`.
- * @snippet test_unit_search.cxx search-conjunction
+ * @snippet{trimleft} test_unit_search.cxx search-conjunction
  *
  * @see https://docs.couchbase.com/server/current/fts/fts-supported-queries-conjuncts-disjuncts.html
  * server documentation