couchbase 4.5.0 → 4.5.1

package/deps/couchbase-cxx-cache/mozilla-ca-bundle.crt

@@ -1,7 +1,7 @@
 ##
 ## Bundle of CA Root Certificates
 ##
-## Certificate data from Mozilla as of: Tue May 20 03:12:02 2025 GMT
+## Certificate data from Mozilla as of: Tue Sep  9 03:12:01 2025 GMT
 ##
 ## Find updated versions here: https://curl.se/docs/caextract.html
 ##
@@ -16,7 +16,7 @@
 ## Just configure this file as the SSLCACertificateFile.
 ##
 ## Conversion done with mk-ca-bundle.pl version 1.29.
-## SHA256: 8944ec6b572b577daee4fc681a425881f841ec2660e4cb5f0eee727f84620697
+## SHA256: 0078e6bdd280fd89e1b883174387aae84b3eae2ee263416a5f8a14ee7f179ae9
 ##
 
 
@@ -3448,6 +3448,51 @@ WoC9EV2Ta/vH5mQ/u2kc6d0li690yVRAysuTEwrt+2aSEcr1wPrYg1UDfNPFIkZ1cGt5SAYqgpq/
 n/mtd+ArY0+ew+43u3gJhJ65bvspmZDogNOfJA==
 -----END CERTIFICATE-----
 
+TrustAsia TLS ECC Root CA
+=========================
+-----BEGIN CERTIFICATE-----
+MIICMTCCAbegAwIBAgIUNnThTXxlE8msg1UloD5Sfi9QaMcwCgYIKoZIzj0EAwMwWDELMAkGA1UE
+BhMCQ04xJTAjBgNVBAoTHFRydXN0QXNpYSBUZWNobm9sb2dpZXMsIEluYy4xIjAgBgNVBAMTGVRy
+dXN0QXNpYSBUTFMgRUNDIFJvb3QgQ0EwHhcNMjQwNTE1MDU0MTU2WhcNNDQwNTE1MDU0MTU1WjBY
+MQswCQYDVQQGEwJDTjElMCMGA1UEChMcVHJ1c3RBc2lhIFRlY2hub2xvZ2llcywgSW5jLjEiMCAG
+A1UEAxMZVHJ1c3RBc2lhIFRMUyBFQ0MgUm9vdCBDQTB2MBAGByqGSM49AgEGBSuBBAAiA2IABLh/
+pVs/AT598IhtrimY4ZtcU5nb9wj/1WrgjstEpvDBjL1P1M7UiFPoXlfXTr4sP/MSpwDpguMqWzJ8
+S5sUKZ74LYO1644xST0mYekdcouJtgq7nDM1D9rs3qlKH8kzsaNCMEAwDwYDVR0TAQH/BAUwAwEB
+/zAdBgNVHQ4EFgQULIVTu7FDzTLqnqOH/qKYqKaT6RAwDgYDVR0PAQH/BAQDAgEGMAoGCCqGSM49
+BAMDA2gAMGUCMFRH18MtYYZI9HlaVQ01L18N9mdsd0AaRuf4aFtOJx24mH1/k78ITcTaRTChD15K
+eAIxAKORh/IRM4PDwYqROkwrULG9IpRdNYlzg8WbGf60oenUoWa2AaU2+dhoYSi3dOGiMQ==
+-----END CERTIFICATE-----
+
+TrustAsia TLS RSA Root CA
+=========================
+-----BEGIN CERTIFICATE-----
+MIIFgDCCA2igAwIBAgIUHBjYz+VTPyI1RlNUJDxsR9FcSpwwDQYJKoZIhvcNAQEMBQAwWDELMAkG
+A1UEBhMCQ04xJTAjBgNVBAoTHFRydXN0QXNpYSBUZWNobm9sb2dpZXMsIEluYy4xIjAgBgNVBAMT
+GVRydXN0QXNpYSBUTFMgUlNBIFJvb3QgQ0EwHhcNMjQwNTE1MDU0MTU3WhcNNDQwNTE1MDU0MTU2
+WjBYMQswCQYDVQQGEwJDTjElMCMGA1UEChMcVHJ1c3RBc2lhIFRlY2hub2xvZ2llcywgSW5jLjEi
+MCAGA1UEAxMZVHJ1c3RBc2lhIFRMUyBSU0EgUm9vdCBDQTCCAiIwDQYJKoZIhvcNAQEBBQADggIP
+ADCCAgoCggIBAMMWuBtqpERz5dZO9LnPWwvB0ZqB9WOwj0PBuwhaGnrhB3YmH49pVr7+NmDQDIPN
+lOrnxS1cLwUWAp4KqC/lYCZUlviYQB2srp10Zy9U+5RjmOMmSoPGlbYJQ1DNDX3eRA5gEk9bNb2/
+mThtfWza4mhzH/kxpRkQcwUqwzIZheo0qt1CHjCNP561HmHVb70AcnKtEj+qpklz8oYVlQwQX1Fk
+zv93uMltrOXVmPGZLmzjyUT5tUMnCE32ft5EebuyjBza00tsLtbDeLdM1aTk2tyKjg7/D8OmYCYo
+zza/+lcK7Fs/6TAWe8TbxNRkoDD75f0dcZLdKY9BWN4ArTr9PXwaqLEX8E40eFgl1oUh63kd0Nyr
+z2I8sMeXi9bQn9P+PN7F4/w6g3CEIR0JwqH8uyghZVNgepBtljhb//HXeltt08lwSUq6HTrQUNoy
+IBnkiz/r1RYmNzz7dZ6wB3C4FGB33PYPXFIKvF1tjVEK2sUYyJtt3LCDs3+jTnhMmCWr8n4uIF6C
+FabW2I+s5c0yhsj55NqJ4js+k8UTav/H9xj8Z7XvGCxUq0DTbE3txci3OE9kxJRMT6DNrqXGJyV1
+J23G2pyOsAWZ1SgRxSHUuPzHlqtKZFlhaxP8S8ySpg+kUb8OWJDZgoM5pl+z+m6Ss80zDoWo8SnT
+q1mt1tve1CuBAgMBAAGjQjBAMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFLgHkXlcBvRG/XtZ
+ylomkadFK/hTMA4GA1UdDwEB/wQEAwIBBjANBgkqhkiG9w0BAQwFAAOCAgEAIZtqBSBdGBanEqT3
+Rz/NyjuujsCCztxIJXgXbODgcMTWltnZ9r96nBO7U5WS/8+S4PPFJzVXqDuiGev4iqME3mmL5Dw8
+veWv0BIb5Ylrc5tvJQJLkIKvQMKtuppgJFqBTQUYo+IzeXoLH5Pt7DlK9RME7I10nYEKqG/odv6L
+TytpEoYKNDbdgptvT+Bz3Ul/KD7JO6NXBNiT2Twp2xIQaOHEibgGIOcberyxk2GaGUARtWqFVwHx
+tlotJnMnlvm5P1vQiJ3koP26TpUJg3933FEFlJ0gcXax7PqJtZwuhfG5WyRasQmr2soaB82G39tp
+27RIGAAtvKLEiUUjpQ7hRGU+isFqMB3iYPg6qocJQrmBktwliJiJ8Xw18WLK7nn4GS/+X/jbh87q
+qA8MpugLoDzga5SYnH+tBuYc6kIQX+ImFTw3OffXvO645e8D7r0i+yiGNFjEWn9hongPXvPKnbwb
+PKfILfanIhHKA9jnZwqKDss1jjQ52MjqjZ9k4DewbNfFj8GQYSbbJIweSsCI3zWQzj8C9GRh3sfI
+B5XeMhg6j6JCQCTl1jNdfK7vsU1P1FeQNWrcrgSXSYk0ly4wBOeY99sLAZDBHwo/+ML+TvrbmnNz
+FrwFuHnYWa8G5z9nODmxfKuU4CkUpijy323imttUQ/hHWKNddBWcwauwxzQ=
+-----END CERTIFICATE-----
+
 D-TRUST EV Root CA 2 2023
 =========================
 -----BEGIN CERTIFICATE-----
@@ -3478,3 +3523,34 @@ S5THaJQXfuKOKD62xur1NGyfN4gHONuGcfrNlUhDbqNPgofXNJhuS5N5YHVpD/Aa1VP6IQzCP+k/
 HxiMkl14p3ZnGbuy6n/pcAlWVqOwDAstNl7F6cTVg8uGF5csbBNvh1qvSaYd2804BC5f4ko1Di1L
 +KIkBI3Y4WNeApI02phhXBxvWHZks/wCuPWdCg==
 -----END CERTIFICATE-----
+
+SwissSign RSA TLS Root CA 2022 - 1
+==================================
+-----BEGIN CERTIFICATE-----
+MIIFkzCCA3ugAwIBAgIUQ/oMX04bgBhE79G0TzUfRPSA7cswDQYJKoZIhvcNAQELBQAwUTELMAkG
+A1UEBhMCQ0gxFTATBgNVBAoTDFN3aXNzU2lnbiBBRzErMCkGA1UEAxMiU3dpc3NTaWduIFJTQSBU
+TFMgUm9vdCBDQSAyMDIyIC0gMTAeFw0yMjA2MDgxMTA4MjJaFw00NzA2MDgxMTA4MjJaMFExCzAJ
+BgNVBAYTAkNIMRUwEwYDVQQKEwxTd2lzc1NpZ24gQUcxKzApBgNVBAMTIlN3aXNzU2lnbiBSU0Eg
+VExTIFJvb3QgQ0EgMjAyMiAtIDEwggIiMA0GCSqGSIb3DQEBAQUAA4ICDwAwggIKAoICAQDLKmji
+C8NXvDVjvHClO/OMPE5Xlm7DTjak9gLKHqquuN6orx122ro10JFwB9+zBvKK8i5VUXu7LCTLf5Im
+gKO0lPaCoaTo+nUdWfMHamFk4saMla+ju45vVs9xzF6BYQ1t8qsCLqSX5XH8irCRIFucdFJtrhUn
+WXjyCcplDn/L9Ovn3KlMd/YrFgSVrpxxpT8q2kFC5zyEEPThPYxr4iuRR1VPuFa+Rd4iUU1OKNlf
+GUEGjw5NBuBwQCMBauTLE5tzrE0USJIt/m2n+IdreXXhvhCxqohAWVTXz8TQm0SzOGlkjIHRI36q
+OTw7D59Ke4LKa2/KIj4x0LDQKhySio/YGZxH5D4MucLNvkEM+KRHBdvBFzA4OmnczcNpI/2aDwLO
+EGrOyvi5KaM2iYauC8BPY7kGWUleDsFpswrzd34unYyzJ5jSmY0lpx+Gs6ZUcDj8fV3oT4MM0ZPl
+EuRU2j7yrTrePjxF8CgPBrnh25d7mUWe3f6VWQQvdT/TromZhqwUtKiE+shdOxtYk8EXlFXIC+OC
+eYSf8wCENO7cMdWP8vpPlkwGqnj73mSiI80fPsWMvDdUDrtaclXvyFu1cvh43zcgTFeRc5JzrBh3
+Q4IgaezprClG5QtO+DdziZaKHG29777YtvTKwP1H8K4LWCDFyB02rpeNUIMmJCn3nTsPBQIDAQAB
+o2MwYTAPBgNVHRMBAf8EBTADAQH/MA4GA1UdDwEB/wQEAwIBBjAfBgNVHSMEGDAWgBRvjmKLk0Ow
+4UD2p8P98Q+4DxU4pTAdBgNVHQ4EFgQUb45ii5NDsOFA9qfD/fEPuA8VOKUwDQYJKoZIhvcNAQEL
+BQADggIBAKwsKUF9+lz1GpUYvyypiqkkVHX1uECry6gkUSsYP2OprphWKwVDIqO310aewCoSPY6W
+lkDfDDOLazeROpW7OSltwAJsipQLBwJNGD77+3v1dj2b9l4wBlgzHqp41eZUBDqyggmNzhYzWUUo
+8aWjlw5DI/0LIICQ/+Mmz7hkkeUFjxOgdg3XNwwQiJb0Pr6VvfHDffCjw3lHC1ySFWPtUnWK50Zp
+y1FVCypM9fJkT6lc/2cyjlUtMoIcgC9qkfjLvH4YoiaoLqNTKIftV+Vlek4ASltOU8liNr3Cjlvr
+zG4ngRhZi0Rjn9UMZfQpZX+RLOV/fuiJz48gy20HQhFRJjKKLjpHE7iNvUcNCfAWpO2Whi4Z2L6M
+OuhFLhG6rlrnub+xzI/goP+4s9GFe3lmozm1O2bYQL7Pt2eLSMkZJVX8vY3PXtpOpvJpzv1/THfQ
+wUY1mFwjmwJFQ5Ra3bxHrSL+ul4vkSkphnsh3m5kt8sNjzdbowhq6/TdAo9QAwKxuDdollDruF/U
+KIqlIgyKhPBZLtU30WHlQnNYKoH3dtvi4k0NX/a3vgW0rk4N3hY9A4GzJl5LuEsAz/+MF7psYC0n
+hzck5npgL7XTgwSqT0N1osGDsieYK7EOgLrAhV5Cud+xYJHT6xh+cHiudoO+cVrQkOPKwRYlZ0rw
+tnu64ZzZ
+-----END CERTIFICATE-----

package/deps/couchbase-cxx-cache/mozilla-ca-bundle.sha256

@@ -1 +1 @@
-ab3ee3651977a4178a702b0b828a4ee7b2bbb9127235b0ab740e2e15974bf5db  cacert.pem
+f290e6acaf904a4121424ca3ebdd70652780707e28e8af999221786b86bb1975  cacert.pem

package/deps/couchbase-cxx-client/CMakeLists.txt

@@ -21,7 +21,7 @@ endif()
 
 project(
   couchbase_cxx_client
-  VERSION "1.1.0"
+  VERSION "1.1.1"
   LANGUAGES CXX C)
 message(STATUS "Couchbase C++ client ${couchbase_cxx_client_VERSION} build ${couchbase_cxx_client_BUILD_NUMBER}, master: ${COUCHBASE_CXX_CLIENT_MASTER_PROJECT}")
 message(STATUS "System: ${CMAKE_SYSTEM_NAME}, ${CMAKE_SYSTEM_VERSION}, ${CMAKE_SYSTEM_PROCESSOR}")
@@ -510,14 +510,14 @@ foreach(TARGET ${couchbase_cxx_client_LIBRARIES})
   set_target_properties(${TARGET} PROPERTIES POSITION_INDEPENDENT_CODE ON)
 
   target_include_directories(
-    ${TARGET} PRIVATE $<BUILD_INTERFACE:${PROJECT_SOURCE_DIR}>
-                      $<BUILD_INTERFACE:${PROJECT_BINARY_DIR}/generated>
+    ${TARGET} PRIVATE $<BUILD_INTERFACE:${PROJECT_BINARY_DIR}/generated>
                       $<BUILD_INTERFACE:${PROJECT_BINARY_DIR}/generated_$<CONFIG>>)
 
   target_include_directories(
     ${TARGET} SYSTEM PRIVATE $<BUILD_INTERFACE:${PROJECT_SOURCE_DIR}/third_party/cxx_function>
                              $<BUILD_INTERFACE:${PROJECT_SOURCE_DIR}/third_party/expected/include>)
 
+  target_include_directories(${TARGET} PUBLIC $<BUILD_INTERFACE:${PROJECT_SOURCE_DIR}>)
   target_include_directories(${TARGET} PUBLIC $<INSTALL_INTERFACE:${CMAKE_INSTALL_INCLUDEDIR}>)
 
   enable_sanitizers(${TARGET})

package/deps/couchbase-cxx-client/README.md

@@ -21,9 +21,9 @@ CPMAddPackage(
   NAME
   couchbase_cxx_client
   GIT_TAG
-  1.1.0
+  1.1.1
   VERSION
-  1.1.0
+  1.1.1
   GITHUB_REPOSITORY
   "couchbase/couchbase-cxx-client"
   OPTIONS

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

@@ -34,17 +34,24 @@
 
 namespace couchbase::core
 {
+struct node_labels {
+  std::string node;
+  std::optional<std::string> alt_node;
+};
+
 class app_telemetry_meter_impl
 {
 public:
   app_telemetry_meter_impl() = default;
-  app_telemetry_meter_impl(app_telemetry_meter_impl&&) = default;
+  app_telemetry_meter_impl(app_telemetry_meter_impl&&) = delete;
   app_telemetry_meter_impl(const app_telemetry_meter_impl&) = delete;
-  auto operator=(app_telemetry_meter_impl&&) -> app_telemetry_meter_impl& = default;
+  auto operator=(app_telemetry_meter_impl&&) -> app_telemetry_meter_impl& = delete;
   auto operator=(const app_telemetry_meter_impl&) -> app_telemetry_meter_impl& = delete;
   virtual ~app_telemetry_meter_impl() = default;
 
   virtual auto enabled() -> bool = 0;
+  [[nodiscard]] virtual auto current_node_labels() const -> std::map<std::string, node_labels> = 0;
+  virtual void set_node_labels_cache(std::map<std::string, node_labels>) = 0;
   virtual auto nothing_to_report() -> bool = 0;
   virtual void update_config(const topology::configuration& config) = 0;
   virtual auto value_recorder(const std::string& node_uuid, const std::string& bucket_name)
@@ -101,11 +108,6 @@ namespace couchbase::core
 {
 namespace
 {
-struct node_labels {
-  std::string node;
-  std::optional<std::string> alt_node;
-};
-
 struct kv_non_durable_histogram {
   const char* name;
   std::atomic_uint64_t le_1ms{};
@@ -349,6 +351,16 @@ public:
   {
     /* do nothing */
   }
+
+  [[nodiscard]] auto current_node_labels() const -> std::map<std::string, node_labels> override
+  {
+    return {};
+  }
+
+  void set_node_labels_cache(std::map<std::string, node_labels>) override
+  {
+    /* do nothing */
+  }
 };
 
 class default_app_telemetry_value_recorder : public app_telemetry_value_recorder
@@ -600,6 +612,7 @@ public:
 
   void update_config(const topology::configuration& config) override
   {
+    node_uuids_in_last_config_.clear();
     for (const auto& node : config.nodes) {
       std::optional<std::string> alt_node{};
       if (auto it = node.alt.find("external"); it != node.alt.end()) {
@@ -611,6 +624,7 @@ public:
         node.hostname,
         alt_node,
       };
+      node_uuids_in_last_config_.push_back(node.node_uuid);
     }
   }
 
@@ -625,6 +639,23 @@ public:
     return recorders_.empty();
   }
 
+  [[nodiscard]] auto current_node_labels() const -> std::map<std::string, node_labels> override
+  {
+    std::map<std::string, node_labels> labels{};
+    for (const auto& node_uuid : node_uuids_in_last_config_) {
+      labels[node_uuid] = labels_cache_.at(node_uuid);
+    }
+    return labels;
+  }
+
+  void set_node_labels_cache(std::map<std::string, node_labels> labels) override
+  {
+    for (const auto& [node_uuid, _] : labels) {
+      node_uuids_in_last_config_.push_back(node_uuid);
+    }
+    labels_cache_ = std::move(labels);
+  }
+
   void generate_to(std::vector<std::byte>& buffer, const std::string& agent) override
   {
     auto now = std::chrono::duration_cast<std::chrono::milliseconds>(
@@ -677,6 +708,7 @@ private:
            std::map<std::string, std::shared_ptr<default_app_telemetry_value_recorder>>>
     recorders_{};
   std::map<std::string, node_labels> labels_cache_{};
+  std::vector<std::string> node_uuids_in_last_config_{};
 };
 
 auto
@@ -699,6 +731,7 @@ app_telemetry_meter::app_telemetry_meter()
 void
 app_telemetry_meter::disable()
 {
+  const std::scoped_lock lock{ impl_mutex_ };
   if (!impl_->enabled()) {
     return;
   }
@@ -712,6 +745,7 @@ app_telemetry_meter::disable()
 void
 app_telemetry_meter::enable()
 {
+  const std::scoped_lock lock{ impl_mutex_ };
   if (impl_->enabled()) {
     return;
   }
@@ -730,6 +764,7 @@ app_telemetry_meter::~app_telemetry_meter() = default;
 void
 app_telemetry_meter::update_config(const topology::configuration& config)
 {
+  const std::shared_lock lock{ impl_mutex_ };
   return impl_->update_config(config);
 }
 
@@ -737,17 +772,20 @@ auto
 app_telemetry_meter::value_recorder(const std::string& node_uuid, const std::string& bucket_name)
   -> std::shared_ptr<app_telemetry_value_recorder>
 {
+  const std::shared_lock lock{ impl_mutex_ };
   return impl_->value_recorder(node_uuid, bucket_name);
 }
 
 void
 app_telemetry_meter::generate_report(std::vector<std::byte>& output_buffer)
 {
+  const std::scoped_lock lock{ impl_mutex_ };
   if (impl_->nothing_to_report()) {
     return;
   }
-  auto old_impl = std::move(impl_);
+  const auto old_impl = std::move(impl_);
   impl_ = std::make_unique<default_app_telemetry_meter_impl>();
+  impl_->set_node_labels_cache(old_impl->current_node_labels());
   old_impl->generate_to(output_buffer, agent_);
 }
 } // namespace couchbase::core

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

@@ -20,6 +20,7 @@
 #include <chrono>
 #include <cstdint>
 #include <memory>
+#include <shared_mutex>
 #include <string>
 #include <vector>
 
@@ -175,9 +176,9 @@ class app_telemetry_meter
 {
 public:
   app_telemetry_meter();
-  app_telemetry_meter(app_telemetry_meter&&) = default;
+  app_telemetry_meter(app_telemetry_meter&&) = delete;
   app_telemetry_meter(const app_telemetry_meter&) = delete;
-  auto operator=(app_telemetry_meter&&) -> app_telemetry_meter& = default;
+  auto operator=(app_telemetry_meter&&) -> app_telemetry_meter& = delete;
   auto operator=(const app_telemetry_meter&) -> app_telemetry_meter& = delete;
   ~app_telemetry_meter();
 
@@ -193,6 +194,7 @@ public:
 private:
   std::string agent_;
   std::unique_ptr<app_telemetry_meter_impl> impl_;
+  std::shared_mutex impl_mutex_{};
 };
 
 } // namespace couchbase::core

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

@@ -350,9 +350,10 @@ public:
     }
 
     origin_ = std::move(origin);
-    CB_LOG_DEBUG(R"(open cluster, id: "{}", core version: "{}", {})",
+    CB_LOG_DEBUG(R"(open cluster, id: "{}", core version: "{}", connection string: {}, {})",
                  id_,
                  couchbase::core::meta::sdk_semver(),
+                 origin_.connection_string(),
                  origin_.to_json());
     setup_observability();
     if (origin_.options().enable_dns_srv) {

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

@@ -107,6 +107,7 @@ public:
   std::chrono::milliseconds app_telemetry_backoff_interval{
     timeout_defaults::app_telemetry_backoff_interval
   };
+  bool preserve_bootstrap_nodes_order{ false };
 };
 
 } // namespace couchbase::core

package/deps/couchbase-cxx-client/core/impl/cluster.cxx

@@ -140,6 +140,7 @@ options_to_origin(const std::string& connection_string, const couchbase::cluster
   user_options.enable_mutation_tokens = opts.behavior.enable_mutation_tokens;
   user_options.enable_unordered_execution = opts.behavior.enable_unordered_execution;
   user_options.user_agent_extra = opts.behavior.user_agent_extra;
+  user_options.preserve_bootstrap_nodes_order = opts.behavior.preserve_bootstrap_nodes_order;
 
   user_options.server_group = opts.network.server_group;
   user_options.enable_tcp_keep_alive = opts.network.enable_tcp_keep_alive;

package/deps/couchbase-cxx-client/core/impl/error.cxx

@@ -185,15 +185,30 @@ make_error(const couchbase::core::transaction_error_context& ctx) -> error
 }
 
 auto
-make_error(const couchbase::core::transaction_op_error_context& ctx) -> error
+make_error(const core::transactions::op_exception& exc) -> error
 {
-  if (std::holds_alternative<key_value_error_context>(ctx.cause())) {
-    return { ctx.ec(), {}, {}, make_error(std::get<key_value_error_context>(ctx.cause())) };
+  std::optional<error> cause;
+  if (std::holds_alternative<key_value_error_context>(exc.ctx().cause())) {
+    cause = make_error(std::get<key_value_error_context>(exc.ctx().cause()));
   }
-  if (std::holds_alternative<query_error_context>(ctx.cause())) {
-    return { ctx.ec(), {}, {}, make_error(std::get<query_error_context>(ctx.cause())) };
+  if (std::holds_alternative<query_error_context>(exc.ctx().cause())) {
+    cause = make_error(std::get<query_error_context>(exc.ctx().cause()));
   }
-  return ctx.ec();
+
+  if (cause.has_value()) {
+    return error{
+      transaction_op_errc_from_external_exception(exc.cause()),
+      exc.what(),
+      {},
+      cause.value(),
+    };
+  }
+
+  return error{
+    transaction_op_errc_from_external_exception(exc.cause()),
+    exc.what(),
+    {},
+  };
 }
 
 auto

package/deps/couchbase-cxx-client/core/impl/error.hxx

@@ -57,7 +57,7 @@ auto
 make_error(const couchbase::core::transaction_error_context& core_ctx) -> error;
 
 auto
-make_error(const couchbase::core::transaction_op_error_context& core_ctx) -> error;
+make_error(const couchbase::core::transactions::op_exception& exc) -> error;
 
 auto
 make_error(const couchbase::core::transactions::transaction_operation_failed& core_tof) -> error;

package/deps/couchbase-cxx-client/core/io/http_session_manager.hxx

@@ -114,8 +114,11 @@ public:
   void update_config(topology::configuration config) override
   {
     {
-      std::scoped_lock config_lock(config_mutex_, sessions_mutex_);
+      std::scoped_lock config_lock(config_mutex_, sessions_mutex_, next_index_mutex_);
       config_ = std::move(config);
+      if (!config_.nodes.empty() && next_index_ >= config_.nodes.size()) {
+        next_index_ = 0;
+      }
       for (auto& [type, sessions] : idle_sessions_) {
         sessions.remove_if([&opts = options_, &cfg = config_](const auto& session) {
           return session && !cfg.has_node(opts.network,

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
@@ -338,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) {
@@ -345,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
@@ -360,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;
@@ -399,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;
 }
@@ -428,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

@@ -55,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:
@@ -86,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/transactions/attempt_context_impl.cxx

@@ -103,7 +103,7 @@ wrap_call_for_public_api(std::function<transaction_get_result()>&& handler)
   } catch (const transaction_operation_failed& e) {
     return { core::impl::make_error(e), {} };
   } catch (const op_exception& ex) {
-    return { core::impl::make_error(ex.ctx()), {} };
+    return { core::impl::make_error(ex), {} };
   } catch (...) {
     // the handler should catch everything else, but just in case...
     return { { errc::transaction_op::generic }, {} };
@@ -123,7 +123,7 @@ wrap_callback_for_async_public_api(
     try {
       std::rethrow_exception(err);
     } catch (const op_exception& e) {
-      return cb(core::impl::make_error(e.ctx()), {});
+      return cb(core::impl::make_error(e), {});
     } catch (const transaction_operation_failed& e) {
       return cb(core::impl::make_error(e), {});
     } catch (...) {
@@ -649,7 +649,7 @@ attempt_context_impl::get_multi(
       try {
         std::rethrow_exception(err);
       } catch (const op_exception& e) {
-        return cb(core::impl::make_error(e.ctx()), {});
+        return cb(core::impl::make_error(e), {});
       } catch (const transaction_operation_failed& e) {
         return cb(core::impl::make_error(e), {});
       } catch (...) {
@@ -766,7 +766,7 @@ attempt_context_impl::get_multi_replicas_from_preferred_server_group(
         try {
           std::rethrow_exception(err);
         } catch (const op_exception& e) {
-          return cb(core::impl::make_error(e.ctx()), {});
+          return cb(core::impl::make_error(e), {});
         } catch (const transaction_operation_failed& e) {
           return cb(core::impl::make_error(e), {});
         } catch (...) {
@@ -2139,11 +2139,25 @@ attempt_context_impl::do_public_query(
   try {
     auto result = do_core_query(statement, opts, query_context);
     auto [ctx, res] = core::impl::build_transaction_query_result(result);
-    return std::make_pair(core::impl::make_error(ctx), res);
+    if (ctx.ec()) {
+      // This should have already been converted to an exception by handle_query_error, which we
+      // handle above. Let's return an error here just in case
+      std::string msg = "Txns query error occured that should have been handled further upstream, "
+                        "which might indicate a bug.";
+      if (std::holds_alternative<query_error_context>(ctx.cause())) {
+        return { { ctx.ec(),
+                   std::move(msg),
+                   {},
+                   impl::make_error(std::get<query_error_context>(ctx.cause())) },
+                 {} };
+      }
+      return { { ctx.ec(), std::move(msg) }, {} };
+    }
+    return { {}, res };
   } catch (const transaction_operation_failed& e) {
     return { core::impl::make_error(e), {} };
   } catch (const op_exception& qe) {
-    return { core::impl::make_error(qe.ctx()), {} };
+    return { core::impl::make_error(qe), {} };
   } catch (...) {
     // should not be necessary, but just in case...
     return { { couchbase::errc::transaction_op::generic }, {} };
@@ -2267,7 +2281,7 @@ attempt_context_impl::insert_raw_with_query(const core::document_id& id,
               std::rethrow_exception(err);
             } catch (const transaction_operation_failed& e) {
               return self->op_completed_with_error(std::move(cb), e);
-            } catch (const document_exists& ex) {
+            } catch (const op_exception& ex) {
               return self->op_completed_with_error(std::move(cb), ex);
             } catch (const std::exception& e) {
               return self->op_completed_with_error(
@@ -4029,14 +4043,28 @@ attempt_context_impl::query(std::string statement,
             } catch (const transaction_operation_failed& e) {
               return handler(core::impl::make_error(e), {});
             } catch (const op_exception& ex) {
-              return handler(core::impl::make_error(ex.ctx()), {});
+              return handler(core::impl::make_error(ex), {});
             } catch (...) {
               // just in case...
               return handler({ couchbase::errc::transaction_op::generic }, {});
             }
           }
           auto [ctx, res] = core::impl::build_transaction_query_result(*resp);
-          handler(core::impl::make_error(ctx), res);
+          if (ctx.ec()) {
+            // This should have already been converted to an exception by handle_query_error,
+            // which we handle above. Let's return an error here just in case
+            std::string msg = "Txns query error occured that should have been handled further "
+                              "upstream, which might indicate a bug.";
+            if (std::holds_alternative<query_error_context>(ctx.cause())) {
+              return handler({ ctx.ec(),
+                               std::move(msg),
+                               {},
+                               impl::make_error(std::get<query_error_context>(ctx.cause())) },
+                             {});
+            }
+            return handler({ ctx.ec(), std::move(msg) }, {});
+          }
+          return handler({}, res);
         });
 }
 

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

@@ -52,7 +52,8 @@ public:
 
   [[nodiscard]] auto exists(std::size_t spec_index) const -> bool
   {
-    return spec_index >= content_.size() && content_[spec_index].has_value();
+    Expects(spec_index < content_.size());
+    return content_[spec_index].has_value();
   }
 
   [[nodiscard]] auto content() const -> const std::vector<std::optional<codec::encoded_value>>&

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

@@ -47,7 +47,8 @@ public:
 
   [[nodiscard]] auto exists(std::size_t spec_index) const -> bool
   {
-    return spec_index >= content_.size() && content_[spec_index].has_value();
+    Expects(spec_index < content_.size());
+    return content_[spec_index].has_value();
   }
 
   [[nodiscard]] auto content() const -> const std::vector<std::optional<codec::encoded_value>>&

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

@@ -586,6 +586,8 @@ extract_options(connection_string& connstr)
       parse_option(connstr.options.enable_app_telemetry, name, value, connstr.warnings);
     } else if (name == "app_telemetry_endpoint") {
       parse_option(connstr.options.app_telemetry_endpoint, name, value, connstr.warnings);
+    } else if (name == "preserve_bootstrap_nodes_order") {
+      parse_option(connstr.options.preserve_bootstrap_nodes_order, name, value, connstr.warnings);
     } else {
       connstr.warnings.push_back(
         fmt::format(R"(unknown parameter "{}" in connection string (value "{}"))", name, value));
@@ -598,6 +600,7 @@ auto
 parse_connection_string(const std::string& input, cluster_options options) -> connection_string
 {
   connection_string res{};
+  res.input = input;
   res.options = std::move(options);
 
   if (input.empty()) {

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

@@ -57,6 +57,7 @@ struct connection_string {
     }
   };
 
+  std::string input;
   std::string scheme{ "couchbase" };
   bool tls{ false };
   std::map<std::string, std::string> params{};

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

@@ -67,6 +67,12 @@ public:
     return *this;
   }
 
+  auto preserve_bootstrap_nodes_order(bool enable) -> behavior_options&
+  {
+    preserve_bootstrap_nodes_order_ = enable;
+    return *this;
+  }
+
   struct built {
     std::string user_agent_extra;
     bool show_queries;
@@ -75,6 +81,7 @@ public:
     bool enable_unordered_execution;
     bool dump_configuration;
     std::string network;
+    bool preserve_bootstrap_nodes_order;
   };
 
   [[nodiscard]] auto build() const -> built
@@ -87,6 +94,7 @@ public:
       enable_unordered_execution_,
       dump_configuration_,
       network_,
+      preserve_bootstrap_nodes_order_,
     };
   }
 
@@ -98,5 +106,6 @@ private:
   bool enable_unordered_execution_{ true };
   bool dump_configuration_{ false };
   std::string network_{ "auto" };
+  bool preserve_bootstrap_nodes_order_{ false };
 };
 } // namespace couchbase

package/deps/couchbase-cxx-client/couchbase/transactions/transaction_get_multi_replicas_from_preferred_server_group_result.hxx

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

package/deps/couchbase-cxx-client/couchbase/transactions/transaction_get_multi_result.hxx

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

package/package.json

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