couchbase 4.4.2 → 4.4.4

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

@@ -587,9 +587,9 @@ attempt_context_impl::create_document_metadata(
 }
 
 void
-attempt_context_impl::replace_raw(const transaction_get_result& document,
-                                  codec::encoded_value content,
-                                  Callback&& cb)
+attempt_context_impl::replace(const transaction_get_result& document,
+                              codec::encoded_value content,
+                              Callback&& cb)
 {
 
   if (op_list_.get_mode().is_query()) {
@@ -852,19 +852,19 @@ attempt_context_impl::create_staged_replace(const transaction_get_result& docume
 }
 
 auto
-attempt_context_impl::replace_raw(const transaction_get_result& document,
-                                  codec::encoded_value content) -> transaction_get_result
+attempt_context_impl::replace(const transaction_get_result& document,
+                              codec::encoded_value content) -> transaction_get_result
 {
   auto barrier = std::make_shared<std::promise<transaction_get_result>>();
   auto f = barrier->get_future();
-  replace_raw(document,
-              std::move(content),
-              [barrier](const std::exception_ptr& err, std::optional<transaction_get_result> res) {
-                if (err) {
-                  return barrier->set_exception(err);
-                }
-                barrier->set_value(std::move(*res));
-              });
+  replace(document,
+          std::move(content),
+          [barrier](const std::exception_ptr& err, std::optional<transaction_get_result> res) {
+            if (err) {
+              return barrier->set_exception(err);
+            }
+            barrier->set_value(std::move(*res));
+          });
   return f.get();
 }
 
@@ -873,12 +873,12 @@ attempt_context_impl::replace_raw(couchbase::transactions::transaction_get_resul
                                   codec::encoded_value content,
                                   couchbase::transactions::async_result_handler&& handler)
 {
-  replace_raw(core::transactions::transaction_get_result(doc),
-              std::move(content),
-              [handler = std::move(handler)](const std::exception_ptr& err,
-                                             std::optional<transaction_get_result> res) mutable {
-                wrap_callback_for_async_public_api(err, std::move(res), std::move(handler));
-              });
+  replace(core::transactions::transaction_get_result(doc),
+          std::move(content),
+          [handler = std::move(handler)](const std::exception_ptr& err,
+                                         std::optional<transaction_get_result> res) mutable {
+            wrap_callback_for_async_public_api(err, std::move(res), std::move(handler));
+          });
 }
 
 auto
@@ -888,7 +888,7 @@ attempt_context_impl::replace_raw(const couchbase::transactions::transaction_get
 {
   return wrap_call_for_public_api(
     [self = shared_from_this(), doc, content = std::move(content)]() -> transaction_get_result {
-      return self->replace_raw(transaction_get_result(doc), content);
+      return self->replace(transaction_get_result(doc), content);
     });
 }
 
@@ -900,8 +900,8 @@ attempt_context_impl::insert_raw(const collection& coll,
 {
   return wrap_call_for_public_api(
     [self = shared_from_this(), coll, &id, content = std::move(content)]() mutable {
-      return self->insert_raw({ coll.bucket_name(), coll.scope_name(), coll.name(), id },
-                              std::move(content));
+      return self->insert({ coll.bucket_name(), coll.scope_name(), coll.name(), id },
+                          std::move(content));
     });
 }
 
@@ -911,35 +911,35 @@ attempt_context_impl::insert_raw(const collection& coll,
                                  codec::encoded_value content,
                                  couchbase::transactions::async_result_handler&& handler)
 {
-  insert_raw({ coll.bucket_name(), coll.scope_name(), coll.name(), std::move(id) },
-             std::move(content),
-             [handler = std::move(handler)](const std::exception_ptr& err,
-                                            std::optional<transaction_get_result> res) mutable {
-               wrap_callback_for_async_public_api(err, std::move(res), std::move(handler));
-             });
+  insert({ coll.bucket_name(), coll.scope_name(), coll.name(), std::move(id) },
+         std::move(content),
+         [handler = std::move(handler)](const std::exception_ptr& err,
+                                        std::optional<transaction_get_result> res) mutable {
+           wrap_callback_for_async_public_api(err, std::move(res), std::move(handler));
+         });
 }
 
 auto
-attempt_context_impl::insert_raw(const core::document_id& id,
-                                 codec::encoded_value content) -> transaction_get_result
+attempt_context_impl::insert(const core::document_id& id,
+                             codec::encoded_value content) -> transaction_get_result
 {
   auto barrier = std::make_shared<std::promise<transaction_get_result>>();
   auto f = barrier->get_future();
-  insert_raw(id,
-             std::move(content),
-             [barrier](const std::exception_ptr& err, std::optional<transaction_get_result> res) {
-               if (err) {
-                 return barrier->set_exception(err);
-               }
-               barrier->set_value(std::move(*res));
-             });
+  insert(id,
+         std::move(content),
+         [barrier](const std::exception_ptr& err, std::optional<transaction_get_result> res) {
+           if (err) {
+             return barrier->set_exception(err);
+           }
+           barrier->set_value(std::move(*res));
+         });
   return f.get();
 }
 
 void
-attempt_context_impl::insert_raw(const core::document_id& id,
-                                 codec::encoded_value content,
-                                 Callback&& cb)
+attempt_context_impl::insert(const core::document_id& id,
+                             codec::encoded_value content,
+                             Callback&& cb)
 {
   if (op_list_.get_mode().is_query()) {
     return insert_raw_with_query(id, std::move(content), std::move(cb));
@@ -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

@@ -92,37 +92,36 @@ private:
   // transaction_context needs access to the two functions below
   friend class transaction_context;
 
+  void insert(const core::document_id& id,
+              codec::encoded_value content,
+              core::transactions::async_attempt_context::Callback&& cb) override;
+
+  auto insert(const core::document_id& id,
+              codec::encoded_value content) -> core::transactions::transaction_get_result override;
+
+  void replace(const transaction_get_result& document,
+               codec::encoded_value content,
+               core::transactions::async_attempt_context::Callback&& cb) override;
+
+  auto replace(const transaction_get_result& document,
+               codec::encoded_value content) -> transaction_get_result override;
+
   auto insert_raw(const collection& coll, const std::string& id, codec::encoded_value content)
     -> std::pair<couchbase::error, couchbase::transactions::transaction_get_result> override;
-  auto insert_raw(const core::document_id& id, codec::encoded_value content)
-    -> core::transactions::transaction_get_result override;
 
   void insert_raw(const collection& coll,
                   std::string id,
                   codec::encoded_value content,
                   couchbase::transactions::async_result_handler&& handler) override;
 
-  void insert_raw(
-    const core::document_id& id,
-    codec::encoded_value content,
-    std::function<void(std::exception_ptr, std::optional<transaction_get_result>)>&& cb) override;
-
   auto replace_raw(const couchbase::transactions::transaction_get_result& doc,
                    codec::encoded_value content)
     -> std::pair<couchbase::error, couchbase::transactions::transaction_get_result> override;
 
-  auto replace_raw(const transaction_get_result& document,
-                   codec::encoded_value content) -> transaction_get_result override;
-
   void replace_raw(couchbase::transactions::transaction_get_result doc,
                    codec::encoded_value content,
                    couchbase::transactions::async_result_handler&& handler) override;
 
-  void replace_raw(
-    const transaction_get_result& document,
-    codec::encoded_value content,
-    std::function<void(std::exception_ptr, std::optional<transaction_get_result>)>&& cb) override;
-
   void remove_staged_insert(const core::document_id& id, VoidCallback&& cb);
 
   void get_with_query(
@@ -200,7 +199,7 @@ private:
                                std::exception_ptr&& err)
   {
     try {
-      std::rethrow_exception(std::move(err));
+      std::rethrow_exception(err);
     } catch (const transaction_operation_failed& e) {
       // if this is a transaction_operation_failed, we need to cache it before
       // moving on...
@@ -463,8 +462,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/transaction_context.cxx

@@ -180,7 +180,7 @@ transaction_context::insert(const core::document_id& id,
                             async_attempt_context::Callback&& cb)
 {
   if (current_attempt_context_) {
-    return current_attempt_context_->insert_raw(id, std::move(content), std::move(cb));
+    return current_attempt_context_->insert(id, std::move(content), std::move(cb));
   }
   throw transaction_operation_failed(FAIL_OTHER, "no current attempt context");
 }
@@ -191,7 +191,7 @@ transaction_context::replace(const transaction_get_result& doc,
                              async_attempt_context::Callback&& cb)
 {
   if (current_attempt_context_) {
-    return current_attempt_context_->replace_raw(doc, std::move(content), std::move(cb));
+    return current_attempt_context_->replace(doc, std::move(content), std::move(cb));
   }
   throw transaction_operation_failed(FAIL_OTHER, "no current attempt context");
 }

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

@@ -199,26 +199,6 @@ public:
     return os;
   }
 
-  /**
-   * Content of the document.
-   *
-   * @return content of the document.
-   */
-  template<typename Document,
-           typename Transcoder = codec::default_json_transcoder,
-           std::enable_if_t<!codec::is_transcoder_v<Document>, bool> = true,
-           std::enable_if_t<codec::is_transcoder_v<Transcoder>, bool> = true>
-  [[nodiscard]] auto content() const -> Document
-  {
-    return Transcoder::template decode<Document>(content_);
-  }
-
-  template<typename Transcoder, std::enable_if_t<codec::is_transcoder_v<Transcoder>, bool> = true>
-  [[nodiscard]] auto content() const -> typename Transcoder::document_type
-  {
-    return Transcoder::decode(content_);
-  }
-
   /**
    * Content of the document as raw byte vector
    *

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/couchbase/analytics_options.hxx

@@ -241,7 +241,7 @@ struct analytics_options : public common_options<analytics_options> {
            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(Serializer::template serialize(value));
+    raw_[std::move(name)] = std::move(Serializer::template serialize<const Value&>(value));
     return self();
   }
 
@@ -359,7 +359,8 @@ private:
            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(Serializer::template serialize(parameter)));
+    positional_parameters_.emplace_back(
+      std::move(Serializer::template serialize<Parameter>(parameter)));
     if constexpr (sizeof...(args) > 0) {
       encode_positional_parameters<Serializer>(args...);
     }
@@ -373,7 +374,7 @@ private:
   void encode_named_parameters(const std::pair<Name, Parameter>& parameter, Rest... args)
   {
     named_parameters_[parameter.first] =
-      std::move(Serializer::template serialize(parameter.second));
+      std::move(Serializer::template serialize<Parameter>(parameter.second));
     if constexpr (sizeof...(args) > 0) {
       encode_named_parameters<Serializer>(args...);
     }

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));