couchbase 4.4.2 → 4.4.3

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

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

@@ -235,7 +235,7 @@ public:
   template<typename Value, typename Transcoder = codec::default_json_transcoder>
   static auto upsert(std::string path, const Value& value) -> subdoc::upsert
   {
-    return { std::move(path), std::move(Transcoder::template encode(value).data) };
+    return { std::move(path), std::move(Transcoder::template encode<const Value&>(value).data) };
   }
 
   /**
@@ -453,7 +453,7 @@ public:
   template<typename Value, typename Transcoder = codec::default_json_transcoder>
   static auto array_add_unique(std::string path, const Value& value) -> subdoc::array_add_unique
   {
-    return { std::move(path), std::move(Transcoder::template encode(value).data) };
+    return { std::move(path), std::move(Transcoder::template encode<Value>(value).data) };
   }
 
   /**

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

@@ -445,7 +445,7 @@ struct query_options : public common_options<query_options> {
            std::enable_if_t<codec::is_serializer_v<Serializer>, bool> = true>
   auto raw(std::string name, const Value& value) -> query_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();
   }
 
@@ -563,7 +563,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<const Parameter&>(parameter)));
     if constexpr (sizeof...(args) > 0) {
       encode_positional_parameters<Serializer>(args...);
     }
@@ -577,7 +578,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/search_options.hxx

@@ -192,7 +192,7 @@ struct search_options : public common_options<search_options> {
            std::enable_if_t<codec::is_serializer_v<Serializer>, bool> = true>
   auto raw(std::string name, const Value& value) -> search_options&
   {
-    raw_[std::move(name)] = std::move(Serializer::template serialize(value));
+    raw_[std::move(name)] = std::move(Serializer::template serialize<Value>(value));
     return self();
   }
 

package/package.json

@@ -54,7 +54,7 @@
     "type": "git",
     "url": "http://github.com/couchbase/couchnode.git"
   },
-  "version": "4.4.2",
+  "version": "4.4.3",
   "config": {
     "native": false
   },
@@ -79,13 +79,13 @@
     ]
   },
   "optionalDependencies": {
-    "@couchbase/couchbase-darwin-arm64-napi": "4.4.2",
-    "@couchbase/couchbase-darwin-x64-napi": "4.4.2",
-    "@couchbase/couchbase-linux-arm64-napi": "4.4.2",
-    "@couchbase/couchbase-linuxmusl-arm64-napi": "4.4.2",
-    "@couchbase/couchbase-linuxmusl-x64-napi": "4.4.2",
-    "@couchbase/couchbase-linux-x64-napi": "4.4.2",
-    "@couchbase/couchbase-win32-x64-napi": "4.4.2"
+    "@couchbase/couchbase-darwin-arm64-napi": "4.4.3",
+    "@couchbase/couchbase-darwin-x64-napi": "4.4.3",
+    "@couchbase/couchbase-linux-arm64-napi": "4.4.3",
+    "@couchbase/couchbase-linuxmusl-arm64-napi": "4.4.3",
+    "@couchbase/couchbase-linuxmusl-x64-napi": "4.4.3",
+    "@couchbase/couchbase-linux-x64-napi": "4.4.3",
+    "@couchbase/couchbase-win32-x64-napi": "4.4.3"
   },
   "files": [
     "LICENSE",

package/src/binding.cpp

@@ -9,7 +9,6 @@
 #include <core/logger/configuration.hxx>
 #include <core/meta/version.hxx>
 #include <napi.h>
-#include <spdlog/spdlog.h>
 
 namespace couchnode
 {
@@ -39,40 +38,41 @@ Napi::Value shutdown_logger(const Napi::CallbackInfo &info)
 
 Napi::Object Init(Napi::Env env, Napi::Object exports)
 {
-    spdlog::set_pattern("[%Y-%m-%d %T.%e] [%P,%t] [%^%l%$] %oms, %v");
-
-    auto spdLogLevel = spdlog::level::off;
     auto cbppLogLevel = couchbase::core::logger::level::off;
     {
         const char *logLevelCstr = getenv("CBPPLOGLEVEL");
         if (logLevelCstr) {
             std::string logLevelStr = logLevelCstr;
             if (logLevelStr == "trace") {
-                spdLogLevel = spdlog::level::trace;
                 cbppLogLevel = couchbase::core::logger::level::trace;
             } else if (logLevelStr == "debug") {
-                spdLogLevel = spdlog::level::debug;
                 cbppLogLevel = couchbase::core::logger::level::debug;
             } else if (logLevelStr == "info") {
-                spdLogLevel = spdlog::level::info;
                 cbppLogLevel = couchbase::core::logger::level::info;
             } else if (logLevelStr == "warn") {
-                spdLogLevel = spdlog::level::warn;
                 cbppLogLevel = couchbase::core::logger::level::warn;
             } else if (logLevelStr == "err") {
-                spdLogLevel = spdlog::level::err;
                 cbppLogLevel = couchbase::core::logger::level::err;
             } else if (logLevelStr == "critical") {
-                spdLogLevel = spdlog::level::critical;
                 cbppLogLevel = couchbase::core::logger::level::critical;
             }
         }
     }
+
     if (cbppLogLevel != couchbase::core::logger::level::off) {
-        couchbase::core::logger::create_console_logger();
+        const char *logFileCstr = getenv("CBPPLOGFILE");
+        if (logFileCstr) {
+            std::string logFileStr = logFileCstr;
+            couchbase::core::logger::configuration configuration{};
+            configuration.filename = logFileStr;
+            configuration.log_level = cbppLogLevel;
+            couchbase::core::logger::create_file_logger(configuration);
+
+        } else {
+            couchbase::core::logger::create_console_logger();
+            couchbase::core::logger::set_log_levels(cbppLogLevel);
+        }
     }
-    spdlog::set_level(spdLogLevel);
-    couchbase::core::logger::set_log_levels(cbppLogLevel);
 
     AddonData::Init(env, exports);
     Constants::Init(env, exports);