couchbase 4.1.2 → 4.1.3

package/deps/couchbase-transactions-cxx/src/transactions/transaction_get_result.cxx

@@ -19,7 +19,7 @@
 namespace couchbase::transactions
 {
 transaction_get_result
-transaction_get_result::create_from(const couchbase::operations::lookup_in_response& resp)
+transaction_get_result::create_from(const core::operations::lookup_in_response& resp)
 {
     std::optional<std::string> atr_id;
     std::optional<std::string> transaction_id;
@@ -45,56 +45,56 @@ transaction_get_result::create_from(const couchbase::operations::lookup_in_respo
     std::optional<std::string> op;
     std::string content;
 
-    if (resp.fields[0].status == protocol::status::success) {
-        atr_id = default_json_serializer::deserialize_from_json_string<std::string>(resp.fields[0].value);
+    if (resp.fields[0].status == key_value_status_code::success) {
+        atr_id = default_json_serializer::deserialize_from_json_string<std::string>(to_string(resp.fields[0].value));
     }
-    if (resp.fields[1].status == protocol::status::success) {
-        transaction_id = default_json_serializer::deserialize_from_json_string<std::string>(resp.fields[1].value);
+    if (resp.fields[1].status == key_value_status_code::success) {
+        transaction_id = default_json_serializer::deserialize_from_json_string<std::string>(to_string(resp.fields[1].value));
     }
-    if (resp.fields[2].status == protocol::status::success) {
-        attempt_id = default_json_serializer::deserialize_from_json_string<std::string>(resp.fields[2].value);
+    if (resp.fields[2].status == key_value_status_code::success) {
+        attempt_id = default_json_serializer::deserialize_from_json_string<std::string>(to_string(resp.fields[2].value));
     }
-    if (resp.fields[3].status == protocol::status::success) {
-        staged_content = resp.fields[3].value;
+    if (resp.fields[3].status == key_value_status_code::success) {
+        staged_content = to_string(resp.fields[3].value);
     }
-    if (resp.fields[4].status == protocol::status::success) {
-        atr_bucket_name = default_json_serializer::deserialize_from_json_string<std::string>(resp.fields[4].value);
+    if (resp.fields[4].status == key_value_status_code::success) {
+        atr_bucket_name = default_json_serializer::deserialize_from_json_string<std::string>(to_string(resp.fields[4].value));
     }
-    if (resp.fields[5].status == protocol::status::success) {
-        atr_scope_name = default_json_serializer::deserialize_from_json_string<std::string>(resp.fields[5].value);
+    if (resp.fields[5].status == key_value_status_code::success) {
+        atr_scope_name = default_json_serializer::deserialize_from_json_string<std::string>(to_string(resp.fields[5].value));
     }
-    if (resp.fields[6].status == protocol::status::success) {
-        atr_collection_name = default_json_serializer::deserialize_from_json_string<std::string>(resp.fields[6].value);
+    if (resp.fields[6].status == key_value_status_code::success) {
+        atr_collection_name = default_json_serializer::deserialize_from_json_string<std::string>(to_string(resp.fields[6].value));
     }
 
-    if (resp.fields[7].status == protocol::status::success) {
-        auto restore = nlohmann::json::parse(resp.fields[7].value);
+    if (resp.fields[7].status == key_value_status_code::success) {
+        auto restore = nlohmann::json::parse(to_string(resp.fields[7].value));
         cas_pre_txn = restore["CAS"].get<std::string>();
         // only present in 6.5+
         revid_pre_txn = restore["revid"].get<std::string>();
         exptime_pre_txn = restore["exptime"].get<uint32_t>();
     }
-    if (resp.fields[8].status == protocol::status::success) {
-        op = default_json_serializer::deserialize_from_json_string<std::string>(resp.fields[8].value);
+    if (resp.fields[8].status == key_value_status_code::success) {
+        op = default_json_serializer::deserialize_from_json_string<std::string>(to_string(resp.fields[8].value));
     }
-    if (resp.fields[9].status == protocol::status::success) {
-        auto doc = nlohmann::json::parse(resp.fields[9].value);
+    if (resp.fields[9].status == key_value_status_code::success) {
+        auto doc = nlohmann::json::parse(to_string(resp.fields[9].value));
         cas_from_doc = doc["CAS"].get<std::string>();
         // only present in 6.5+
         revid_from_doc = doc["revid"].get<std::string>();
         exptime_from_doc = doc["exptime"].get<uint32_t>();
         crc32_from_doc = doc["value_crc32c"].get<std::string>();
     }
-    if (resp.fields[10].status == protocol::status::success) {
-        crc32_of_staging = default_json_serializer::deserialize_from_json_string<std::string>(resp.fields[10].value);
+    if (resp.fields[10].status == key_value_status_code::success) {
+        crc32_of_staging = default_json_serializer::deserialize_from_json_string<std::string>(to_string(resp.fields[10].value));
     }
-    if (resp.fields[11].status == protocol::status::success) {
-        forward_compat = nlohmann::json::parse(resp.fields[11].value);
+    if (resp.fields[11].status == key_value_status_code::success) {
+        forward_compat = nlohmann::json::parse(to_string(resp.fields[11].value));
     } else {
         forward_compat = nlohmann::json::object();
     }
-    if (resp.fields[12].status == protocol::status::success) {
-        content = resp.fields[12].value;
+    if (resp.fields[12].status == key_value_status_code::success) {
+        content = to_string(resp.fields[12].value);
     }
 
     transaction_links links(atr_id,
@@ -112,11 +112,15 @@ transaction_get_result::create_from(const couchbase::operations::lookup_in_respo
                             forward_compat,
                             resp.deleted);
     document_metadata md(cas_from_doc, revid_from_doc, exptime_from_doc, crc32_from_doc);
-    return { resp.ctx.id, content, resp.cas.value, links, std::make_optional(md) };
+    return { { resp.ctx.bucket(), resp.ctx.scope(), resp.ctx.collection(), resp.ctx.id() },
+             content,
+             resp.cas.value(),
+             links,
+             std::make_optional(md) };
 }
 
 transaction_get_result
-transaction_get_result::create_from(const couchbase::document_id& id, const result& res)
+transaction_get_result::create_from(const core::document_id& id, const result& res)
 {
     std::optional<std::string> atr_id;
     std::optional<std::string> transaction_id;

package/deps/couchbase-transactions-cxx/src/transactions/transaction_query_options.cxx

@@ -19,14 +19,14 @@
 namespace couchbase::transactions
 {
 
-couchbase::operations::query_request
+core::operations::query_request
 transaction_query_options::wrap_request(const couchbase::transactions::transaction_context& txn_context) const
 {
     // set timeout stuff using the config/context.
     // extra time so we don't timeout right at expiry.
-    auto extra = txn_context.config().kv_timeout() ? txn_context.config().kv_timeout().value()
-                                                   : couchbase::timeout_defaults::key_value_durable_timeout;
-    couchbase::operations::query_request req = query_req_;
+    auto extra =
+      txn_context.config().kv_timeout() ? txn_context.config().kv_timeout().value() : core::timeout_defaults::key_value_durable_timeout;
+    core::operations::query_request req = query_req_;
     if (!req.scan_consistency) {
         req.scan_consistency = txn_context.config().scan_consistency();
     }

package/deps/couchbase-transactions-cxx/src/transactions/transactions.cxx

@@ -24,7 +24,7 @@
 
 namespace tx = couchbase::transactions;
 
-tx::transactions::transactions(cluster& cluster, const transaction_config& config)
+tx::transactions::transactions(core::cluster& cluster, const transaction_config& config)
   : cluster_(cluster)
   , config_(config)
   , cleanup_(new transactions_cleanup(cluster_, config_))

package/deps/couchbase-transactions-cxx/src/transactions/transactions_cleanup.cxx

@@ -14,9 +14,6 @@
  *   limitations under the License.
  */
 
-#include <algorithm>
-#include <chrono>
-#include <functional>
 #include "active_transaction_record.hxx"
 #include "atr_ids.hxx"
 #include "attempt_context_impl.hxx"
@@ -28,6 +25,10 @@
 #include "couchbase/transactions/internal/utils.hxx"
 #include "uid_generator.hxx"
 
+#include <algorithm>
+#include <chrono>
+#include <functional>
+
 namespace tx = couchbase::transactions;
 
 tx::transactions_cleanup_attempt::transactions_cleanup_attempt(const tx::atr_cleanup_entry& entry)
@@ -38,7 +39,7 @@ tx::transactions_cleanup_attempt::transactions_cleanup_attempt(const tx::atr_cle
 {
 }
 
-tx::transactions_cleanup::transactions_cleanup(couchbase::cluster& cluster, const tx::transaction_config& config)
+tx::transactions_cleanup::transactions_cleanup(core::cluster& cluster, const tx::transaction_config& config)
   : cluster_(cluster)
   , config_(config)
   , client_uuid_(uid_generator::next())
@@ -185,7 +186,7 @@ tx::transactions_cleanup::clean_lost_attempts_in_bucket(const std::string& bucke
 }
 
 const tx::atr_cleanup_stats
-tx::transactions_cleanup::handle_atr_cleanup(const couchbase::document_id& atr_id, std::vector<transactions_cleanup_attempt>* results)
+tx::transactions_cleanup::handle_atr_cleanup(const core::document_id& atr_id, std::vector<transactions_cleanup_attempt>* results)
 {
     atr_cleanup_stats stats;
     auto atr = active_transaction_record::get_atr(cluster_, atr_id);
@@ -223,11 +224,16 @@ tx::transactions_cleanup::create_client_record(const std::string& bucket_name)
 {
     try {
         auto id = config_.atr_id_from_bucket_and_key(bucket_name, CLIENT_RECORD_DOC_ID);
-        couchbase::operations::mutate_in_request req{ id };
-        req.store_semantics = protocol::mutate_in_request_body::store_semantics_type::insert;
-        req.specs.add_spec(protocol::subdoc_opcode::dict_add, true, true, false, FIELD_CLIENTS, "{}");
-        // ExtBinaryMetadata
-        req.specs.add_spec(protocol::subdoc_opcode::set_doc, false, false, false, std::string(""), jsonify(std::string({ 0x00 })));
+        core::operations::mutate_in_request req{ id };
+        req.store_semantics = couchbase::store_semantics::insert;
+        req.specs =
+          couchbase::mutate_in_specs{
+              couchbase::mutate_in_specs::insert(FIELD_CLIENTS, tao::json::empty_object).xattr().create_path(),
+              // subdoc::opcode::set_doc used in replace w/ empty path
+              // ExtBinaryMetadata
+              couchbase::mutate_in_specs::replace({}, std::string({ 0x00 })),
+          }
+            .specs();
         wrap_durable_request(req, config_);
         auto barrier = std::make_shared<std::promise<result>>();
         auto f = barrier->get_future();
@@ -235,9 +241,8 @@ tx::transactions_cleanup::create_client_record(const std::string& bucket_name)
         if (ec) {
             throw client_error(*ec, "client_record_before_create hook raised error");
         }
-        cluster_.execute(req, [barrier](couchbase::operations::mutate_in_response resp) {
-            barrier->set_value(result::create_from_subdoc_response(resp));
-        });
+        cluster_.execute(
+          req, [barrier](core::operations::mutate_in_response resp) { barrier->set_value(result::create_from_subdoc_response(resp)); });
         wrap_operation_future(f);
 
     } catch (const tx::client_error& e) {
@@ -266,9 +271,13 @@ tx::transactions_cleanup::get_active_clients(const std::string& bucket_name, con
           // Write our client record, return details.
           try {
               auto id = config_.atr_id_from_bucket_and_key(bucket_name, CLIENT_RECORD_DOC_ID);
-              couchbase::operations::lookup_in_request req{ id };
-              req.specs.add_spec(protocol::subdoc_opcode::get, true, FIELD_RECORDS);
-              req.specs.add_spec(protocol::subdoc_opcode::get, true, "$vbucket");
+              core::operations::lookup_in_request req{ id };
+              req.specs =
+                lookup_in_specs{
+                    lookup_in_specs::get(FIELD_RECORDS).xattr(),
+                    lookup_in_specs::get("$vbucket").xattr(),
+                }
+                  .specs();
               wrap_request(req, config_);
               auto barrier = std::make_shared<std::promise<result>>();
               auto f = barrier->get_future();
@@ -276,7 +285,7 @@ tx::transactions_cleanup::get_active_clients(const std::string& bucket_name, con
               if (ec) {
                   throw client_error(*ec, "client_record_before_get hook raised error");
               }
-              cluster_.execute(req, [barrier](couchbase::operations::lookup_in_response resp) {
+              cluster_.execute(req, [barrier](core::operations::lookup_in_response resp) {
                   barrier->set_value(result::create_from_subdoc_response(resp));
               });
               auto res = wrap_operation_future(f);
@@ -337,30 +346,25 @@ tx::transactions_cleanup::get_active_clients(const std::string& bucket_name, con
               }
 
               // update client record, maybe cleanup some as well...
-              couchbase::operations::mutate_in_request mutate_req{ id };
-              mutate_req.specs.add_spec(protocol::subdoc_opcode::dict_upsert,
-                                        true,
-                                        true,
-                                        true,
-                                        FIELD_CLIENTS + "." + uuid + "." + FIELD_HEARTBEAT,
-                                        mutate_in_macro::CAS);
-              mutate_req.specs.add_spec(protocol::subdoc_opcode::dict_upsert,
-                                        true,
-                                        true,
-                                        false,
-                                        FIELD_CLIENTS + "." + uuid + "." + FIELD_EXPIRES,
-                                        jsonify(config_.cleanup_window().count() / 2 + SAFETY_MARGIN_EXPIRY_MS));
-              mutate_req.specs.add_spec(protocol::subdoc_opcode::dict_upsert,
-                                        true,
-                                        true,
-                                        false,
-                                        FIELD_CLIENTS + "." + uuid + "." + FIELD_NUM_ATRS,
-                                        jsonify(atr_ids::all().size()));
+              core::operations::mutate_in_request mutate_req{ id };
+              auto mut_specs = couchbase::mutate_in_specs{
+                  couchbase::mutate_in_specs::upsert(FIELD_CLIENTS + "." + uuid + "." + FIELD_HEARTBEAT, subdoc::mutate_in_macro::cas)
+                    .xattr()
+                    .create_path(),
+                  couchbase::mutate_in_specs::upsert(FIELD_CLIENTS + "." + uuid + "." + FIELD_EXPIRES,
+                                                     config_.cleanup_window().count() / 2 + SAFETY_MARGIN_EXPIRY_MS)
+                    .xattr()
+                    .create_path(),
+                  couchbase::mutate_in_specs::upsert(FIELD_CLIENTS + "." + uuid + "." + FIELD_NUM_ATRS, atr_ids::all().size())
+                    .xattr()
+                    .create_path(),
+              };
               for (size_t idx = 0; idx < std::min(details.expired_client_ids.size(), static_cast<size_t>(12)); idx++) {
                   lost_attempts_cleanup_log->trace("adding {} to list of clients to be removed when updating this client",
                                                    details.expired_client_ids[idx]);
-                  mutate_req.specs.add_spec(protocol::subdoc_opcode::remove, true, FIELD_CLIENTS + "." + details.expired_client_ids[idx]);
+                  mut_specs.push_back(couchbase::mutate_in_specs::remove(FIELD_CLIENTS + "." + details.expired_client_ids[idx]).xattr());
               }
+              mutate_req.specs = mut_specs.specs();
               ec = config_.cleanup_hooks().client_record_before_update(bucket_name);
               if (ec) {
                   throw client_error(*ec, "client_record_before_update hook raised error");
@@ -369,7 +373,7 @@ tx::transactions_cleanup::get_active_clients(const std::string& bucket_name, con
               auto mutate_barrier = std::make_shared<std::promise<result>>();
               auto mutate_f = mutate_barrier->get_future();
               lost_attempts_cleanup_log->trace("updating record");
-              cluster_.execute(mutate_req, [mutate_barrier](couchbase::operations::mutate_in_response resp) {
+              cluster_.execute(mutate_req, [mutate_barrier](core::operations::mutate_in_response resp) {
                   mutate_barrier->set_value(result::create_from_subdoc_response(resp));
               });
               res = wrap_operation_future(mutate_f);
@@ -409,12 +413,16 @@ tx::transactions_cleanup::remove_client_record_from_all_buckets(const std::strin
                           throw client_error(*ec, "client_record_before_remove_client hook raised error");
                       }
                       auto id = config_.atr_id_from_bucket_and_key(bucket_name, CLIENT_RECORD_DOC_ID);
-                      couchbase::operations::mutate_in_request req{ id };
-                      req.specs.add_spec(protocol::subdoc_opcode::remove, true, FIELD_CLIENTS + "." + uuid);
+                      core::operations::mutate_in_request req{ id };
+                      req.specs =
+                        couchbase::mutate_in_specs{
+                            couchbase::mutate_in_specs::remove(FIELD_CLIENTS + "." + uuid).xattr(),
+                        }
+                          .specs();
                       wrap_durable_request(req, config_);
                       auto barrier = std::make_shared<std::promise<result>>();
                       auto f = barrier->get_future();
-                      cluster_.execute(req, [barrier](couchbase::operations::mutate_in_response resp) {
+                      cluster_.execute(req, [barrier](core::operations::mutate_in_response resp) {
                           barrier->set_value(result::create_from_subdoc_response(resp));
                       });
                       wrap_operation_future(f);
@@ -478,7 +486,7 @@ tx::transactions_cleanup::lost_attempts_loop()
 }
 
 const tx::atr_cleanup_stats
-tx::transactions_cleanup::force_cleanup_atr(const couchbase::document_id& atr_id, std::vector<transactions_cleanup_attempt>& results)
+tx::transactions_cleanup::force_cleanup_atr(const core::document_id& atr_id, std::vector<transactions_cleanup_attempt>& results)
 {
     lost_attempts_cleanup_log->trace("{} starting force_cleanup_atr: atr_id {}", static_cast<void*>(this), atr_id);
     return handle_atr_cleanup(atr_id, &results);

package/deps/couchbase-transactions-cxx/src/transactions/uid_generator.cxx

@@ -14,12 +14,14 @@
  *   limitations under the License.
  */
 
-#include <couchbase/platform/uuid.h>
+#include <core/platform/uuid.h>
 
 #include "uid_generator.hxx"
 
+// TODO: Remove this, and just use client directly
+
 std::string
 couchbase::transactions::uid_generator::next()
 {
-    return couchbase::uuid::to_string(couchbase::uuid::random());
+    return core::uuid::to_string(core::uuid::random());
 }

package/deps/couchbase-transactions-cxx/tests/transactions/logging_t.cpp

@@ -16,7 +16,6 @@
 
 #include "helpers.hxx"
 #include "transactions_env.h"
-#include <couchbase/errors.hxx>
 #include <couchbase/transactions/internal/logging.hxx>
 #include <filesystem>
 #include <fstream>
@@ -48,37 +47,37 @@ class TrivialFileSink : public spdlog::sinks::base_sink<std::mutex>
 
 TEST(LoggingTests, CanLogToStdoutByDefault)
 {
-    couchbase::logger::create_blackhole_logger();
+    couchbase::core::logger::create_blackhole_logger();
     std::string log_message = "I am a log";
-    couchbase::transactions::set_transactions_log_level(couchbase::logger::level::debug);
+    couchbase::transactions::set_transactions_log_level(couchbase::core::logger::level::debug);
     testing::internal::CaptureStdout();
     txn_log->debug(log_message);
     txn_log->flush();
     auto out = testing::internal::GetCapturedStdout();
     ASSERT_FALSE(out.empty());
     ASSERT_NE(std::string::npos, out.find(log_message));
-    couchbase::logger::create_console_logger();
+    couchbase::core::logger::create_console_logger();
 }
 
 TEST(LoggingTests, LogLevelsWork)
 {
-    couchbase::logger::create_blackhole_logger();
+    couchbase::core::logger::create_blackhole_logger();
     std::string log_message = "I am a log";
-    couchbase::transactions::set_transactions_log_level(couchbase::logger::level::info);
+    couchbase::transactions::set_transactions_log_level(couchbase::core::logger::level::info);
     testing::internal::CaptureStdout();
     txn_log->debug(log_message);
     txn_log->flush();
     auto out = testing::internal::GetCapturedStdout();
     ASSERT_TRUE(out.empty());
-    couchbase::logger::create_console_logger();
+    couchbase::core::logger::create_console_logger();
 }
 
 TEST(LoggingTests, CanUseCustomSink)
 {
-    couchbase::logger::create_blackhole_logger();
+    couchbase::core::logger::create_blackhole_logger();
     std::string log_message = "I am a log";
     auto sink = std::make_shared<TrivialFileSink>();
-    couchbase::transactions::create_loggers(couchbase::logger::level::debug, sink);
+    couchbase::transactions::create_loggers(couchbase::core::logger::level::debug, sink);
     testing::internal::CaptureStdout();
     testing::internal::CaptureStderr();
     txn_log->debug(log_message);
@@ -88,15 +87,15 @@ TEST(LoggingTests, CanUseCustomSink)
     auto err = testing::internal::GetCapturedStderr();
     ASSERT_FALSE(err.empty());
     ASSERT_NE(std::string::npos, err.find(log_message)) << "err = " << err;
-    couchbase::logger::create_console_logger();
+    couchbase::core::logger::create_console_logger();
 }
 
 TEST(LoggingTests, CustomSinkRespectsLogLevels)
 {
-    couchbase::logger::create_blackhole_logger();
+    couchbase::core::logger::create_blackhole_logger();
     std::string log_message = "I am a log";
     auto sink = std::make_shared<TrivialFileSink>();
-    couchbase::transactions::create_loggers(couchbase::logger::level::info, sink);
+    couchbase::transactions::create_loggers(couchbase::core::logger::level::info, sink);
     testing::internal::CaptureStdout();
     testing::internal::CaptureStderr();
     txn_log->debug(log_message);
@@ -105,16 +104,16 @@ TEST(LoggingTests, CustomSinkRespectsLogLevels)
     ASSERT_TRUE(out.empty()) << "out = " << out;
     auto err = testing::internal::GetCapturedStderr();
     ASSERT_TRUE(err.empty()) << "err = " << err;
-    couchbase::logger::create_console_logger();
+    couchbase::core::logger::create_console_logger();
 }
 
 TEST(LoggingTests, CustomSinkRespectsLogLevelChanges)
 {
-    couchbase::logger::create_blackhole_logger();
+    couchbase::core::logger::create_blackhole_logger();
     std::string log_message = "I am a log";
     auto sink = std::make_shared<TrivialFileSink>();
-    couchbase::transactions::create_loggers(couchbase::logger::level::debug, sink);
-    couchbase::transactions::set_transactions_log_level(couchbase::logger::level::info);
+    couchbase::transactions::create_loggers(couchbase::core::logger::level::debug, sink);
+    couchbase::transactions::set_transactions_log_level(couchbase::core::logger::level::info);
     testing::internal::CaptureStdout();
     testing::internal::CaptureStderr();
     txn_log->debug(log_message);
@@ -123,5 +122,5 @@ TEST(LoggingTests, CustomSinkRespectsLogLevelChanges)
     ASSERT_TRUE(out.empty()) << "out = " << out;
     auto err = testing::internal::GetCapturedStderr();
     ASSERT_TRUE(err.empty()) << "err = " << err;
-    couchbase::logger::create_console_logger();
+    couchbase::core::logger::create_console_logger();
 }

package/deps/couchbase-transactions-cxx/tests/transactions/simple_async_t.cpp

@@ -18,7 +18,7 @@
 #include "../../src/transactions/attempt_context_testing_hooks.hxx"
 #include "helpers.hxx"
 #include "transactions_env.h"
-#include <couchbase/errors.hxx>
+#include <couchbase/error_codes.hxx>
 #include <couchbase/transactions.hxx>
 #include <gtest/gtest.h>
 #include <spdlog/spdlog.h>
@@ -71,7 +71,7 @@ TEST(SimpleAsyncTxns, AsyncGet)
 TEST(SimpleAsyncTxns, CantGetFromUnknownBucket)
 {
     auto txns = TransactionsTestEnvironment::get_transactions();
-    couchbase::document_id bad_id{ "secBucket", "_default", "default", uid_generator::next() };
+    couchbase::core::document_id bad_id{ "secBucket", "_default", "default", uid_generator::next() };
     std::atomic<bool> cb_called{ false };
     auto barrier = std::make_shared<std::promise<void>>();
     auto f = barrier->get_future();
@@ -136,7 +136,7 @@ TEST(SimpleAsyncTxns, AsyncRemoveFail)
         txns.run(
           [&cb_called, id](async_attempt_context& ctx) {
               ctx.get(id, [&ctx, &cb_called](std::exception_ptr err, std::optional<transaction_get_result> res) {
-                  // lets just change the cas to make it fail, which it should
+                  // let's just change the cas to make it fail, which it should
                   // do until timeout
                   if (!err) {
                       res->cas(100);
@@ -170,7 +170,7 @@ TEST(SimpleAsyncTxns, RYOWOnInsert)
           ctx.insert(id, async_content, [&ctx, &cb_called, id](std::exception_ptr err, std::optional<transaction_get_result> res) {
               EXPECT_FALSE(err);
               EXPECT_TRUE(res);
-              ctx.get(id, [&ctx, &cb_called, id](std::exception_ptr err, std::optional<transaction_get_result> res) {
+              ctx.get(id, [&cb_called, id](std::exception_ptr err, std::optional<transaction_get_result> res) {
                   EXPECT_FALSE(err);
                   EXPECT_TRUE(res);
                   EXPECT_EQ(res->content<nlohmann::json>(), async_content);
@@ -218,7 +218,7 @@ TEST(SimpleAsyncTxns, AsyncRemove)
         TransactionsTestEnvironment::get_doc(id);
         FAIL() << "expected get_doc to raise client exception";
     } catch (const client_error& e) {
-        ASSERT_EQ(e.res()->ec, couchbase::error::key_value_errc::document_not_found);
+        ASSERT_EQ(e.res()->ec, couchbase::errc::key_value::document_not_found);
     }
 }
 
@@ -354,7 +354,7 @@ TEST(SimpleAsyncTxns, AsyncInsertFail)
             TransactionsTestEnvironment::get_doc(id);
             FAIL() << "expected get_doc to raise client exception";
         } catch (const client_error& e) {
-            ASSERT_EQ(e.res()->ec, couchbase::error::key_value_errc::document_not_found);
+            ASSERT_EQ(e.res()->ec, couchbase::errc::key_value::document_not_found);
         }
     }
 }
@@ -370,7 +370,7 @@ TEST(SimpleQueryAsyncTxns, AsyncQuery)
     std::atomic<bool> query_called = false;
     txns.run(
       [&query_called, &query](async_attempt_context& ctx) {
-          ctx.query(query, [&](std::exception_ptr err, std::optional<couchbase::operations::query_response> payload) {
+          ctx.query(query, [&](std::exception_ptr err, std::optional<couchbase::core::operations::query_response> payload) {
               if (!err) {
                   query_called = true;
               }
@@ -398,17 +398,17 @@ TEST(SimpleQueryAsyncTxns, MultipleRacingQueries)
     std::atomic<int> query_called = 0;
     txns.run(
       [&query_called, &query](async_attempt_context& ctx) {
-          ctx.query(query, [&](std::exception_ptr err, std::optional<couchbase::operations::query_response> payload) {
+          ctx.query(query, [&](std::exception_ptr err, std::optional<couchbase::core::operations::query_response> payload) {
               if (!err) {
                   query_called++;
               }
           });
-          ctx.query(query, [&](std::exception_ptr err, std::optional<couchbase::operations::query_response> payload) {
+          ctx.query(query, [&](std::exception_ptr err, std::optional<couchbase::core::operations::query_response> payload) {
               if (!err) {
                   query_called++;
               }
           });
-          ctx.query(query, [&](std::exception_ptr err, std::optional<couchbase::operations::query_response> payload) {
+          ctx.query(query, [&](std::exception_ptr err, std::optional<couchbase::core::operations::query_response> payload) {
               if (!err) {
                   query_called++;
               }
@@ -436,7 +436,7 @@ TEST(SimpleQueryAsyncTxns, RollbackAsyncQuery)
     std::atomic<bool> query_called = false;
     txns.run(
       [&query_called, &query](async_attempt_context& ctx) {
-          ctx.query(query, [&](std::exception_ptr err, std::optional<couchbase::operations::query_response> payload) {
+          ctx.query(query, [&](std::exception_ptr err, std::optional<couchbase::core::operations::query_response> payload) {
               if (!err) {
                   query_called = true;
                   // now rollback by throwing arbitrary exception
@@ -466,7 +466,7 @@ TEST(SimpleQueryAsyncTxns, AsyncKVGet)
     txns.run(
       [&get_called, &query, &id](async_attempt_context& ctx) {
           ctx.get(id, [&](std::exception_ptr err, std::optional<transaction_get_result> result) {
-              ctx.query(query, [&](std::exception_ptr err, std::optional<couchbase::operations::query_response> payload) {
+              ctx.query(query, [&](std::exception_ptr err, std::optional<couchbase::core::operations::query_response> payload) {
                   if (!err) {
                       ctx.get(id, [&](std::exception_ptr err, std::optional<transaction_get_result> result) {
                           if (!err) {
@@ -499,7 +499,7 @@ TEST(SimpleQueryAsyncTxns, RollbackAsyncKVGet)
     txns.run(
       [&get_called, &query, &id](async_attempt_context& ctx) {
           ctx.get(id, [&](std::exception_ptr err, std::optional<transaction_get_result> result) {
-              ctx.query(query, [&](std::exception_ptr err, std::optional<couchbase::operations::query_response> payload) {
+              ctx.query(query, [&](std::exception_ptr err, std::optional<couchbase::core::operations::query_response> payload) {
                   if (!err) {
                       ctx.get(id, [&](std::exception_ptr err, std::optional<transaction_get_result> result) {
                           if (!err) {
@@ -532,7 +532,7 @@ TEST(SimpleQueryAsyncTxns, AsyncKVInsert)
     txns.run(
       [&, barrier](async_attempt_context& ctx) {
           ctx.query("Select 'Yo' as greeting",
-                    [&, barrier](std::exception_ptr err, std::optional<couchbase::operations::query_response> resp) {
+                    [&, barrier](std::exception_ptr err, std::optional<couchbase::core::operations::query_response> resp) {
                         if (!err) {
                             ctx.insert(id, async_content.dump(), [&](std::exception_ptr err, std::optional<transaction_get_result> res) {
                                 insert_called = !err;
@@ -560,7 +560,7 @@ TEST(SimpleQueryAsyncTxns, RollbackAsyncKVInsert)
     txns.run(
       [&, barrier](async_attempt_context& ctx) {
           ctx.query("Select 'Yo' as greeting",
-                    [&, barrier](std::exception_ptr err, std::optional<couchbase::operations::query_response> resp) {
+                    [&, barrier](std::exception_ptr err, std::optional<couchbase::core::operations::query_response> resp) {
                         if (!err) {
                             ctx.insert(id, async_content.dump(), [&](std::exception_ptr err, std::optional<transaction_get_result> res) {
                                 insert_called = !err;
@@ -580,7 +580,7 @@ TEST(SimpleQueryAsyncTxns, RollbackAsyncKVInsert)
     try {
         TransactionsTestEnvironment::get_doc(id);
     } catch (const client_error& e) {
-        ASSERT_EQ(e.res()->ec, couchbase::error::key_value_errc::document_not_found);
+        ASSERT_EQ(e.res()->ec, couchbase::errc::key_value::document_not_found);
     }
 }
 
@@ -601,7 +601,7 @@ TEST(SimpleQueryAsyncTxns, AsyncKVReplace)
               if (!err) {
                   EXPECT_TRUE(result);
                   ctx.query(
-                    query, [&, doc = *result](std::exception_ptr err, std::optional<couchbase::operations::query_response> payload) {
+                    query, [&, doc = *result](std::exception_ptr err, std::optional<couchbase::core::operations::query_response> payload) {
                         if (!err) {
                             ctx.replace(doc, new_content, [&](std::exception_ptr err, std::optional<transaction_get_result> result) {
                                 if (!err) {
@@ -640,7 +640,7 @@ TEST(SimpleQueryAsyncTxns, RollbackAsyncKVReplace)
               if (!err) {
                   EXPECT_TRUE(result);
                   ctx.query(
-                    query, [&, doc = *result](std::exception_ptr err, std::optional<couchbase::operations::query_response> payload) {
+                    query, [&, doc = *result](std::exception_ptr err, std::optional<couchbase::core::operations::query_response> payload) {
                         if (!err) {
                             ctx.replace(doc, new_content, [&](std::exception_ptr err, std::optional<transaction_get_result> result) {
                                 if (!err) {
@@ -679,7 +679,7 @@ TEST(SimpleQueryAsyncTxns, AsyncKVRemove)
               if (!err) {
                   EXPECT_TRUE(result);
                   ctx.query(query,
-                            [&, doc = *result](std::exception_ptr err, std::optional<couchbase::operations::query_response> payload) {
+                            [&, doc = *result](std::exception_ptr err, std::optional<couchbase::core::operations::query_response> payload) {
                                 if (!err) {
                                     ctx.remove(doc, [&](std::exception_ptr err) {
                                         if (!err) {
@@ -701,7 +701,7 @@ TEST(SimpleQueryAsyncTxns, AsyncKVRemove)
     try {
         TransactionsTestEnvironment::get_doc(id);
     } catch (const client_error& e) {
-        ASSERT_EQ(e.res()->ec, couchbase::error::key_value_errc::document_not_found);
+        ASSERT_EQ(e.res()->ec, couchbase::errc::key_value::document_not_found);
     }
 }
 TEST(SimpleQueryAsyncTxns, RollbackAsyncKVRemove)
@@ -720,7 +720,7 @@ TEST(SimpleQueryAsyncTxns, RollbackAsyncKVRemove)
               if (!err) {
                   EXPECT_TRUE(result);
                   ctx.query(query,
-                            [&, doc = *result](std::exception_ptr err, std::optional<couchbase::operations::query_response> payload) {
+                            [&, doc = *result](std::exception_ptr err, std::optional<couchbase::core::operations::query_response> payload) {
                                 if (!err) {
                                     ctx.remove(doc, [&](std::exception_ptr err) {
                                         ASSERT_FALSE(err);