couchbase 4.2.8 → 4.2.9

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

@@ -15,12 +15,14 @@
  */
 
 #include "staged_mutation.hxx"
+
 #include "attempt_context_impl.hxx"
 #include "core/cluster.hxx"
 
 #include "internal/transaction_fields.hxx"
 #include "internal/utils.hxx"
 #include "result.hxx"
+#include "result_fmt.hxx"
 
 #include <asio/bind_executor.hpp>
 #include <asio/post.hpp>
@@ -124,16 +126,16 @@ staged_mutation_queue::extract_to(const std::string& prefix, core::operations::m
 void
 staged_mutation_queue::remove_any(const core::document_id& id)
 {
-    std::lock_guard<std::mutex> lock(mutex_);
+    const std::lock_guard<std::mutex> lock(mutex_);
     auto new_end =
-      std::remove_if(queue_.begin(), queue_.end(), [id](const staged_mutation& item) { return document_ids_equal(item.id(), id); });
+      std::remove_if(queue_.begin(), queue_.end(), [&id](const staged_mutation& item) { return document_ids_equal(item.id(), id); });
     queue_.erase(new_end, queue_.end());
 }
 
 staged_mutation*
 staged_mutation_queue::find_any(const core::document_id& id)
 {
-    std::lock_guard<std::mutex> lock(mutex_);
+    const std::lock_guard<std::mutex> lock(mutex_);
     for (auto& item : queue_) {
         if (document_ids_equal(item.doc().id(), id)) {
             return &item;
@@ -209,7 +211,7 @@ staged_mutation_queue::commit(attempt_context_impl* ctx)
         auto future = barrier->get_future();
 
         try {
-            auto timer = std::make_shared<asio::steady_timer>(ctx->cluster_ref()->io_context());
+            auto timer = std::make_shared<asio::steady_timer>(ctx->cluster_ref().io_context());
             async_constant_delay delay(timer);
 
             switch (item.type()) {
@@ -292,7 +294,7 @@ staged_mutation_queue::rollback(attempt_context_impl* ctx)
         auto future = barrier->get_future();
 
         try {
-            auto timer = std::make_shared<asio::steady_timer>(ctx->cluster_ref()->io_context());
+            auto timer = std::make_shared<asio::steady_timer>(ctx->cluster_ref().io_context());
             async_exp_delay delay(timer);
 
             switch (item.type()) {
@@ -360,7 +362,7 @@ staged_mutation_queue::rollback_insert(attempt_context_impl* ctx,
 {
     CB_ATTEMPT_CTX_LOG_TRACE(ctx, "rolling back staged insert for {} with cas {}", item.doc().id(), item.doc().cas().value());
 
-    asio::post(asio::bind_executor(ctx->cluster_ref()->io_context(), [this, callback = std::move(callback), ctx, &item, delay]() mutable {
+    asio::post(asio::bind_executor(ctx->cluster_ref().io_context(), [this, callback = std::move(callback), ctx, &item, delay]() mutable {
         try {
             auto ec = ctx->error_if_expired_and_not_in_overtime(STAGE_DELETE_INSERTED, item.doc().id().key());
             if (ec) {
@@ -379,7 +381,7 @@ staged_mutation_queue::rollback_insert(attempt_context_impl* ctx,
             req.access_deleted = true;
             req.cas = item.doc().cas();
             wrap_durable_request(req, ctx->overall().config());
-            return ctx->cluster_ref()->execute(
+            return ctx->cluster_ref().execute(
               req, [this, callback = std::move(callback), ctx, &item, delay](const core::operations::mutate_in_response& resp) mutable {
                   CB_ATTEMPT_CTX_LOG_TRACE(ctx, "mutate_in for {} with cas {}", item.doc().id(), item.doc().cas().value());
 
@@ -407,7 +409,7 @@ staged_mutation_queue::rollback_remove_or_replace(attempt_context_impl* ctx,
 {
     CB_ATTEMPT_CTX_LOG_TRACE(ctx, "rolling back staged remove/replace for {} with cas {}", item.doc().id(), item.doc().cas().value());
 
-    asio::post(asio::bind_executor(ctx->cluster_ref()->io_context(), [this, callback = std::move(callback), ctx, &item, delay]() mutable {
+    asio::post(asio::bind_executor(ctx->cluster_ref().io_context(), [this, callback = std::move(callback), ctx, &item, delay]() mutable {
         try {
             auto ec = ctx->error_if_expired_and_not_in_overtime(STAGE_ROLLBACK_DOC, item.doc().id().key());
             if (ec) {
@@ -425,7 +427,7 @@ staged_mutation_queue::rollback_remove_or_replace(attempt_context_impl* ctx,
                 .specs();
             req.cas = item.doc().cas();
             wrap_durable_request(req, ctx->overall().config());
-            return ctx->cluster_ref()->execute(
+            return ctx->cluster_ref().execute(
               req, [this, callback = std::move(callback), ctx, &item, delay](const core::operations::mutate_in_response& resp) mutable {
                   auto res = result::create_from_subdoc_response(resp);
                   try {
@@ -455,7 +457,7 @@ staged_mutation_queue::commit_doc(attempt_context_impl* ctx,
       ctx, "commit doc {}, cas_zero_mode {}, ambiguity_resolution_mode {}", item.doc().id(), cas_zero_mode, ambiguity_resolution_mode);
 
     asio::post(asio::bind_executor(
-      ctx->cluster_ref()->io_context(),
+      ctx->cluster_ref().io_context(),
       [this, callback = std::move(callback), ctx, &item, delay, cas_zero_mode, ambiguity_resolution_mode]() mutable {
           try {
               ctx->check_expiry_during_commit_or_rollback(STAGE_COMMIT_DOC, std::optional<const std::string>(item.doc().id().key()));
@@ -472,7 +474,7 @@ staged_mutation_queue::commit_doc(attempt_context_impl* ctx,
                   core::operations::insert_request req{ item.doc().id(), item.content() };
                   req.flags = couchbase::codec::codec_flags::json_common_flags;
                   wrap_durable_request(req, ctx->overall().config());
-                  return ctx->cluster_ref()->execute(
+                  return ctx->cluster_ref().execute(
                     req,
                     [this, callback = std::move(callback), ctx, &item, delay, ambiguity_resolution_mode, cas_zero_mode](
                       const core::operations::insert_response& resp) mutable {
@@ -498,7 +500,7 @@ staged_mutation_queue::commit_doc(attempt_context_impl* ctx,
                   req.store_semantics = couchbase::store_semantics::replace;
                   req.cas = couchbase::cas(cas_zero_mode ? 0 : item.doc().cas().value());
                   wrap_durable_request(req, ctx->overall().config());
-                  return ctx->cluster_ref()->execute(
+                  return ctx->cluster_ref().execute(
                     req,
                     [this, callback = std::move(callback), ctx, &item, delay, ambiguity_resolution_mode, cas_zero_mode](
                       const core::operations::mutate_in_response resp) mutable {
@@ -527,7 +529,7 @@ staged_mutation_queue::remove_doc(attempt_context_impl* ctx,
 {
     CB_ATTEMPT_CTX_LOG_TRACE(ctx, "remove doc {}", item.doc().id());
 
-    asio::post(asio::bind_executor(ctx->cluster_ref()->io_context(), [this, callback = std::move(callback), ctx, &item, delay]() mutable {
+    asio::post(asio::bind_executor(ctx->cluster_ref().io_context(), [this, callback = std::move(callback), ctx, &item, delay]() mutable {
         try {
             ctx->check_expiry_during_commit_or_rollback(STAGE_REMOVE_DOC, std::optional<const std::string>(item.doc().id().key()));
             auto ec = ctx->hooks_.before_doc_removed(ctx, item.doc().id().key());
@@ -536,7 +538,7 @@ staged_mutation_queue::remove_doc(attempt_context_impl* ctx,
             }
             core::operations::remove_request req{ item.doc().id() };
             wrap_durable_request(req, ctx->overall().config());
-            return ctx->cluster_ref()->execute(
+            return ctx->cluster_ref().execute(
               req, [this, callback = std::move(callback), ctx, &item, delay](core::operations::remove_response resp) mutable {
                   auto res = result::create_from_mutation_response(resp);
                   try {

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

@@ -32,7 +32,7 @@ transaction_context::transaction_context(transactions& txns, const couchbase::tr
   , config_(config.apply(txns.config()))
   , deferred_elapsed_(0)
   , cleanup_(txns.cleanup())
-  , delay_(new exp_delay(std::chrono::milliseconds(1), std::chrono::milliseconds(100), 2 * config_.expiration_time))
+  , delay_(new exp_delay(std::chrono::milliseconds(1), std::chrono::milliseconds(100), 2 * config_.timeout))
 {
     // add metadata_collection to cleanup, if present
     if (config_.metadata_collection) {
@@ -54,7 +54,7 @@ transaction_context::remaining() const
 {
     const auto& now = std::chrono::steady_clock::now();
     auto expired_nanos = std::chrono::duration_cast<std::chrono::nanoseconds>(now - start_time_client_) + deferred_elapsed_;
-    return config_.expiration_time - expired_nanos;
+    return config_.timeout - expired_nanos;
 }
 
 [[nodiscard]] bool
@@ -64,7 +64,7 @@ transaction_context::has_expired_client_side()
     const auto& now = std::chrono::steady_clock::now();
     auto expired_nanos = std::chrono::duration_cast<std::chrono::nanoseconds>(now - start_time_client_) + deferred_elapsed_;
     auto expired_millis = std::chrono::duration_cast<std::chrono::milliseconds>(expired_nanos);
-    bool is_expired = expired_nanos > config_.expiration_time;
+    bool is_expired = expired_nanos > config_.timeout;
     if (is_expired) {
         CB_ATTEMPT_CTX_LOG_INFO(current_attempt_context_,
                                 "has expired client side (now={}ns, start={}ns, deferred_elapsed={}ns, expired={}ns ({}ms), config={}ms)",
@@ -73,7 +73,7 @@ transaction_context::has_expired_client_side()
                                 deferred_elapsed_.count(),
                                 expired_nanos.count(),
                                 expired_millis.count(),
-                                std::chrono::duration_cast<std::chrono::milliseconds>(config_.expiration_time).count());
+                                std::chrono::duration_cast<std::chrono::milliseconds>(config_.timeout).count());
     }
     return is_expired;
 }
@@ -81,7 +81,7 @@ transaction_context::has_expired_client_side()
 void
 transaction_context::after_delay(std::chrono::milliseconds delay, std::function<void()> fn)
 {
-    auto timer = std::make_shared<asio::steady_timer>(this->transactions_.cluster_ref()->io_context());
+    auto timer = std::make_shared<asio::steady_timer>(this->transactions_.cluster_ref().io_context());
     timer->expires_after(delay);
     timer->async_wait([timer, fn](std::error_code) {
         // have to always call the function, even if timer was canceled.
@@ -92,7 +92,7 @@ transaction_context::after_delay(std::chrono::milliseconds delay, std::function<
 void
 transaction_context::new_attempt_context(async_attempt_context::VoidCallback&& cb)
 {
-    asio::post(transactions_.cluster_ref()->io_context(), [this, cb = std::move(cb)]() {
+    asio::post(transactions_.cluster_ref().io_context(), [this, cb = std::move(cb)]() {
         // the first time we call the delay, it just records an end time.  After that, it
         // actually delays.
         try {

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

@@ -0,0 +1,48 @@
+/* -*- Mode: C++; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */
+/*
+ *     Copyright 2021-Present Couchbase, Inc.
+ *
+ *   Licensed under the Apache License, Version 2.0 (the "License");
+ *   you may not use this file except in compliance with the License.
+ *   You may obtain a copy of the License at
+ *
+ *       http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *   Unless required by applicable law or agreed to in writing, software
+ *   distributed under the License is distributed on an "AS IS" BASIS,
+ *   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *   See the License for the specific language governing permissions and
+ *   limitations under the License.
+ */
+
+#include <couchbase/transactions/transaction_keyspace.hxx>
+
+#include <couchbase/collection.hxx>
+#include <couchbase/scope.hxx>
+
+namespace couchbase::transactions
+{
+transaction_keyspace::transaction_keyspace(std::string bucket_name, std::string scope_name, std::string collection_name)
+  : bucket(std::move(bucket_name))
+  , scope(std::move(scope_name))
+  , collection(std::move(collection_name))
+{
+    if (scope.empty()) {
+        scope = couchbase::scope::default_name;
+    }
+    if (collection.empty()) {
+        collection = couchbase::collection::default_name;
+    }
+}
+
+transaction_keyspace::transaction_keyspace(const std::string& bucket_name)
+  : transaction_keyspace{ bucket_name, couchbase::scope::default_name, couchbase::collection::default_name }
+{
+}
+
+bool
+transaction_keyspace::valid()
+{
+    return !bucket.empty() && !scope.empty() && !collection.empty();
+}
+} // namespace couchbase::transactions

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

@@ -257,6 +257,7 @@ struct fmt::formatter<couchbase::core::transactions::transaction_links> {
                          r.atr_scope_name().value_or("none"),
                          r.atr_collection_name().value_or("none"),
                          r.atr_id().value_or("none"),
+                         r.staged_transaction_id().value_or("none"),
                          r.staged_attempt_id().value_or("none"),
                          r.staged_operation_id().value_or("none"),
                          r.crc32_of_staging().value_or("none"));

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

@@ -13,9 +13,12 @@
  *   See the License for the specific language governing permissions and
  *   limitations under the License.
  */
+
+#include <couchbase/collection.hxx>
+#include <couchbase/transactions/transaction_options.hxx>
+
 #include <core/transactions/attempt_context_testing_hooks.hxx>
 #include <core/transactions/cleanup_testing_hooks.hxx>
-#include <couchbase/transactions/transaction_options.hxx>
 
 namespace couchbase::transactions
 {
@@ -27,12 +30,66 @@ transaction_options::apply(const transactions_config::built& conf) const
         query_config.scan_consistency = *scan_consistency_;
     }
     return { durability_.value_or(conf.level),
-             expiration_time_.value_or(conf.expiration_time),
-             kv_timeout_ ? kv_timeout_ : conf.kv_timeout,
+             timeout_.value_or(conf.timeout),
              attempt_context_hooks_ ? attempt_context_hooks_ : conf.attempt_context_hooks,
              cleanup_hooks_ ? cleanup_hooks_ : conf.cleanup_hooks,
              metadata_collection_ ? metadata_collection_ : conf.metadata_collection,
              query_config,
              conf.cleanup_config };
 }
-} // namespace couchbase::transactions
+
+transaction_options&
+transaction_options::test_factories(std::shared_ptr<core::transactions::attempt_context_testing_hooks> hooks,
+                                    std::shared_ptr<core::transactions::cleanup_testing_hooks> cleanup_hooks)
+{
+    attempt_context_hooks_ = hooks;
+    cleanup_hooks_ = cleanup_hooks;
+    return *this;
+}
+
+std::optional<transaction_keyspace>
+transaction_options::metadata_collection() const
+{
+    return metadata_collection_;
+}
+
+transaction_options&
+transaction_options::durability_level(couchbase::durability_level level)
+{
+    durability_ = level;
+    return *this;
+}
+
+std::optional<couchbase::durability_level>
+transaction_options::durability_level() const
+{
+    return durability_;
+}
+
+transaction_options&
+transaction_options::scan_consistency(query_scan_consistency scan_consistency)
+{
+    scan_consistency_ = scan_consistency;
+    return *this;
+}
+
+std::optional<query_scan_consistency>
+transaction_options::scan_consistency() const
+{
+    return scan_consistency_;
+}
+
+std::optional<std::chrono::nanoseconds>
+transaction_options::timeout()
+{
+    return timeout_;
+}
+
+transaction_options&
+transaction_options::metadata_collection(const couchbase::collection& coll)
+{
+    metadata_collection_.emplace(coll.bucket_name(), coll.scope_name(), coll.name());
+    return *this;
+}
+
+} // namespace couchbase::transactions

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

@@ -17,8 +17,9 @@
 #include "attempt_context_impl.hxx"
 
 #include "core/cluster.hxx"
-
+#include "core/meta/version.hxx"
 #include "core/transactions.hxx"
+
 #include "internal/exceptions_internal.hxx"
 #include "internal/logging.hxx"
 #include "internal/transaction_context.hxx"
@@ -27,13 +28,13 @@
 
 namespace couchbase::core::transactions
 {
-transactions::transactions(std::shared_ptr<core::cluster> cluster, const couchbase::transactions::transactions_config& config)
-  : transactions(cluster, config.build())
+transactions::transactions(core::cluster cluster, const couchbase::transactions::transactions_config& config)
+  : transactions(std::move(cluster), config.build())
 {
 }
 
-transactions::transactions(std::shared_ptr<core::cluster> cluster, const couchbase::transactions::transactions_config::built& config)
-  : cluster_(cluster)
+transactions::transactions(core::cluster cluster, const couchbase::transactions::transactions_config::built& config)
+  : cluster_(std::move(cluster))
   , config_(config)
   , cleanup_(new transactions_cleanup(cluster_, config_))
 {
@@ -48,7 +49,7 @@ transactions::transactions(std::shared_ptr<core::cluster> cluster, const couchba
         auto barrier = std::make_shared<std::promise<std::error_code>>();
         auto f = barrier->get_future();
         std::atomic<bool> callback_called{ false };
-        cluster_->open_bucket(config_.metadata_collection->bucket, [&callback_called, barrier](std::error_code ec) {
+        cluster_.open_bucket(config_.metadata_collection->bucket, [&callback_called, barrier](std::error_code ec) {
             if (callback_called.load()) {
                 return;
             }
@@ -59,7 +60,7 @@ transactions::transactions(std::shared_ptr<core::cluster> cluster, const couchba
         if (err) {
             auto err_msg =
               fmt::format("error opening metadata_collection bucket '{}' specified in the config!", config_.metadata_collection->bucket);
-            CB_TXN_LOG_DEBUG(err_msg);
+            CB_TXN_LOG_DEBUG("{}", err_msg);
             throw std::runtime_error(err_msg);
         }
     }
@@ -76,7 +77,7 @@ wrap_run(transactions& txns, const couchbase::transactions::transaction_options&
     while (attempts++ < max_attempts) {
         // NOTE: new_attempt_context has the exponential backoff built in.  So, after
         // the first time it is called, it has a 1ms delay, then 2ms, etc... capped at 100ms
-        // until (for now) a timeout is reached (2x the expiration_time).   Soon, will build in
+        // until (for now) a timeout is reached (2x the timeout).   Soon, will build in
         // a max attempts instead.  In any case, the timeout occurs in the logic - adding
         // a max attempts or timeout is just in case a bug prevents timeout, etc...
         overall.new_attempt_context();

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

@@ -26,8 +26,8 @@
 #include "internal/transactions_cleanup.hxx"
 #include "internal/utils.hxx"
 
-#include <algorithm>
-#include <chrono>
+#include <couchbase/fmt/transaction_keyspace.hxx>
+
 #include <functional>
 
 namespace couchbase::core::transactions
@@ -41,9 +41,8 @@ transactions_cleanup_attempt::transactions_cleanup_attempt(const atr_cleanup_ent
 {
 }
 
-transactions_cleanup::transactions_cleanup(std::shared_ptr<core::cluster> cluster,
-                                           const couchbase::transactions::transactions_config::built& config)
-  : cluster_(cluster)
+transactions_cleanup::transactions_cleanup(core::cluster cluster, const couchbase::transactions::transactions_config::built& config)
+  : cluster_(std::move(cluster))
   , config_(config)
   , client_uuid_(uid_generator::next())
   , running_(config.cleanup_config.cleanup_client_attempts || config.cleanup_config.cleanup_lost_attempts)
@@ -254,8 +253,7 @@ transactions_cleanup::create_client_record(const couchbase::transactions::transa
         if (ec) {
             throw client_error(*ec, "client_record_before_create hook raised error");
         }
-        cluster_->execute(
-          req, [barrier](core::operations::mutate_in_response resp) { barrier->set_value(result::create_from_subdoc_response(resp)); });
+        cluster_.execute(req, [barrier](auto&& resp) { barrier->set_value(result::create_from_subdoc_response(resp)); });
         wrap_operation_future(f);
 
     } catch (const client_error& e) {
@@ -285,15 +283,13 @@ transactions_cleanup::get_active_clients(const couchbase::transactions::transact
               lookup_in_specs::get(subdoc::lookup_in_macro::vbucket).xattr(),
           }
             .specs();
-        wrap_request(req, config_);
         auto barrier = std::make_shared<std::promise<result>>();
         auto f = barrier->get_future();
         auto ec = config_.cleanup_hooks->client_record_before_get(keyspace.bucket);
         if (ec) {
             throw client_error(*ec, "client_record_before_get hook raised error");
         }
-        cluster_->execute(
-          req, [barrier](core::operations::lookup_in_response resp) { barrier->set_value(result::create_from_subdoc_response(resp)); });
+        cluster_.execute(req, [barrier](auto&& resp) { barrier->set_value(result::create_from_subdoc_response(resp)); });
         auto res = wrap_operation_future(f);
 
         std::vector<std::string> active_client_uids;
@@ -375,9 +371,8 @@ transactions_cleanup::get_active_clients(const couchbase::transactions::transact
         auto mutate_barrier = std::make_shared<std::promise<result>>();
         auto mutate_f = mutate_barrier->get_future();
         CB_LOST_ATTEMPT_CLEANUP_LOG_TRACE("updating record");
-        cluster_->execute(mutate_req, [mutate_barrier](core::operations::mutate_in_response resp) {
-            mutate_barrier->set_value(result::create_from_subdoc_response(resp));
-        });
+        cluster_.execute(mutate_req,
+                         [mutate_barrier](auto&& resp) { mutate_barrier->set_value(result::create_from_subdoc_response(resp)); });
         res = wrap_operation_future(mutate_f);
 
         // just update the cas, and return the details
@@ -420,9 +415,7 @@ transactions_cleanup::remove_client_record_from_all_buckets(const std::string& u
                       wrap_durable_request(req, config_);
                       auto barrier = std::make_shared<std::promise<result>>();
                       auto f = barrier->get_future();
-                      cluster_->execute(req, [barrier](core::operations::mutate_in_response resp) {
-                          barrier->set_value(result::create_from_subdoc_response(resp));
-                      });
+                      cluster_.execute(req, [barrier](auto&& resp) { barrier->set_value(result::create_from_subdoc_response(resp)); });
                       wrap_operation_future(f);
                       CB_LOST_ATTEMPT_CLEANUP_LOG_DEBUG("removed {} from {}", uuid, keyspace);
                   } catch (const client_error& e) {

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

@@ -26,7 +26,7 @@ namespace couchbase::transactions
 
 transactions_config::transactions_config()
   : level_(couchbase::durability_level::majority)
-  , expiration_time_(std::chrono::seconds(15))
+  , timeout_(std::chrono::seconds(15))
   , attempt_context_hooks_(new core::transactions::attempt_context_testing_hooks())
   , cleanup_hooks_(new core::transactions::cleanup_testing_hooks())
 {
@@ -36,7 +36,7 @@ transactions_config::~transactions_config() = default;
 
 transactions_config::transactions_config(transactions_config&& c) noexcept
   : level_(c.level_)
-  , expiration_time_(c.expiration_time_)
+  , timeout_(c.timeout_)
   , attempt_context_hooks_(c.attempt_context_hooks_)
   , cleanup_hooks_(c.cleanup_hooks_)
   , metadata_collection_(std::move(c.metadata_collection_))
@@ -47,7 +47,7 @@ transactions_config::transactions_config(transactions_config&& c) noexcept
 
 transactions_config::transactions_config(const transactions_config& config)
   : level_(config.durability_level())
-  , expiration_time_(config.expiration_time())
+  , timeout_(config.timeout())
   , attempt_context_hooks_(std::make_shared<core::transactions::attempt_context_testing_hooks>(config.attempt_context_hooks()))
   , cleanup_hooks_(std::make_shared<core::transactions::cleanup_testing_hooks>(config.cleanup_hooks()))
   , metadata_collection_(config.metadata_collection())
@@ -61,7 +61,7 @@ transactions_config::operator=(const transactions_config& c)
 {
     if (this != &c) {
         level_ = c.level_;
-        expiration_time_ = c.expiration_time_;
+        timeout_ = c.timeout_;
         attempt_context_hooks_ = c.attempt_context_hooks_;
         cleanup_hooks_ = c.cleanup_hooks_;
         query_config_ = c.query_config_;
@@ -74,8 +74,9 @@ transactions_config::operator=(const transactions_config& c)
 transactions_config::built
 transactions_config::build() const
 {
-    return { level_,         expiration_time_,     kv_timeout_,           attempt_context_hooks_,
-             cleanup_hooks_, metadata_collection_, query_config_.build(), cleanup_config_.build() };
+    return {
+        level_, timeout_, attempt_context_hooks_, cleanup_hooks_, metadata_collection_, query_config_.build(), cleanup_config_.build()
+    };
 }
 
 } // namespace couchbase::transactions

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

@@ -25,6 +25,7 @@
 #include "transactions/attempt_context.hxx"
 #include "transactions/exceptions.hxx"
 
+#include "core/cluster.hxx"
 #include "core/logger/logger.hxx"
 
 #include <spdlog/common.h>
@@ -134,8 +135,8 @@ class transactions : public couchbase::transactions::transactions
      * @param cluster The cluster to use for the transactions.
      * @param config The configuration parameters to use for the transactions.
      */
-    transactions(std::shared_ptr<core::cluster> cluster, const couchbase::transactions::transactions_config::built& config);
-    transactions(std::shared_ptr<core::cluster> cluster, const couchbase::transactions::transactions_config& config);
+    transactions(core::cluster cluster, const couchbase::transactions::transactions_config::built& config);
+    transactions(core::cluster cluster, const couchbase::transactions::transactions_config& config);
 
     /**
      * @brief Destructor
@@ -239,17 +240,17 @@ class transactions : public couchbase::transactions::transactions
      *
      * @return Ref to the cluster used by this transaction object.
      */
-    [[nodiscard]] std::shared_ptr<core::cluster> cluster_ref()
+    [[nodiscard]] core::cluster& cluster_ref()
     {
         return cluster_;
     }
 
   private:
-    std::shared_ptr<core::cluster> cluster_;
+    core::cluster cluster_;
     couchbase::transactions::transactions_config::built config_;
     std::unique_ptr<transactions_cleanup> cleanup_;
     const std::size_t max_attempts_{ 1000 };
     const std::chrono::milliseconds min_retry_delay_{ 1 };
 };
 } // namespace transactions
-} // namespace couchbase::core
+} // namespace couchbase::core

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

@@ -46,16 +46,17 @@ join_strings(const Range& values, const std::string& sep)
  * Joins a list of objects together using fmt:: for formatting.
  */
 template<typename Range>
+
 std::string
-join_strings_fmt(const std::string& item_fmt, const Range& values, const std::string& sep)
+join_strings_fmt(const Range& values, const std::string& sep)
 {
     std::stringstream stream;
     auto sentinel = std::end(values);
     if (auto it = std::begin(values); it != sentinel) {
-        stream << fmt::format(item_fmt, *it);
+        stream << fmt::format("{}", *it);
         ++it;
         while (it != sentinel) {
-            stream << sep << fmt::format(item_fmt, *it);
+            stream << sep << fmt::format("{}", *it);
             ++it;
         }
     }

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

@@ -26,11 +26,11 @@ template<typename Request>
 static bool
 check_query_management_request(const Request& req)
 {
-    // if there is a query_context, then bucket, scope should not be specified, but collection should be.
-    // collection should be.
+    // if there is a query_context, then bucket and scope will be ignored
     if (req.query_ctx.has_value()) {
-        return !req.collection_name.empty() && req.bucket_name.empty() && req.scope_name.empty();
+        return true;
     }
+
     // otherwise, both scope and collection must be specified, if one is
     // and bucket _must_ be there as well.
     return !req.bucket_name.empty() &&
@@ -52,4 +52,4 @@ build_keyspace(const Request& req)
     return fmt::format("{}:`{}`.`{}`.`{}`", req.namespace_id, req.bucket_name, req.scope_name, req.collection_name);
 }
 
-} // namespace couchbase::core::utils
+} // namespace couchbase::core::utils

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

@@ -0,0 +1,44 @@
+/* -*- Mode: C++; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */
+/*
+ *   Copyright 2020-Present Couchbase, Inc.
+ *
+ *   Licensed under the Apache License, Version 2.0 (the "License");
+ *   you may not use this file except in compliance with the License.
+ *   You may obtain a copy of the License at
+ *
+ *       http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *   Unless required by applicable law or agreed to in writing, software
+ *   distributed under the License is distributed on an "AS IS" BASIS,
+ *   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *   See the License for the specific language governing permissions and
+ *   limitations under the License.
+ */
+
+#pragma once
+
+#include <couchbase/common_options.hxx>
+#include <couchbase/manager_error_context.hxx>
+
+#include <functional>
+#include <memory>
+#include <optional>
+#include <string>
+
+namespace couchbase
+{
+struct allow_querying_search_index_options : public common_options<allow_querying_search_index_options> {
+  public:
+    struct built : public common_options<allow_querying_search_index_options>::built {
+    };
+
+    [[nodiscard]] auto build() const -> built
+    {
+        return { build_common_options() };
+    }
+
+  private:
+};
+
+using allow_querying_search_index_handler = std::function<void(couchbase::manager_error_context)>;
+} // namespace couchbase