couchbase 4.1.2 → 4.1.3

package/deps/couchbase-transactions-cxx/deps/couchbase-cxx-client/test/utils/integration_test_guard.cxx

@@ -21,12 +21,12 @@
 namespace test::utils
 {
 integration_test_guard::integration_test_guard()
-  : cluster(couchbase::cluster::create(io))
+  : cluster(couchbase::core::cluster::create(io))
   , ctx(test_context::load_from_environment())
 {
     init_logger();
-    auto connstr = couchbase::utils::parse_connection_string(ctx.connection_string);
-    couchbase::cluster_credentials auth{};
+    auto connstr = couchbase::core::utils::parse_connection_string(ctx.connection_string);
+    couchbase::core::cluster_credentials auth{};
     if (!ctx.certificate_path.empty()) {
         auth.certificate_path = ctx.certificate_path;
         auth.key_path = ctx.key_path;
@@ -35,27 +35,42 @@ integration_test_guard::integration_test_guard()
         auth.password = ctx.password;
     }
     io_thread = std::thread([this]() { io.run(); });
-    origin = couchbase::origin(auth, connstr);
+    origin = couchbase::core::origin(auth, connstr);
     open_cluster(cluster, origin);
 }
 
+integration_test_guard::integration_test_guard(const couchbase::core::cluster_options& opts)
+{
+    init_logger();
+    ctx = test_context::load_from_environment();
+    auto auth = ctx.build_auth();
+    auto connstr = couchbase::core::utils::parse_connection_string(ctx.connection_string);
+    // for now, lets _only_ add a tracer or meter from the incoming options
+    connstr.options.meter = opts.meter;
+    connstr.options.tracer = opts.tracer;
+    couchbase::core::origin orig(auth, connstr);
+    cluster = couchbase::core::cluster::create(io);
+    io_thread = std::thread([this]() { io.run(); });
+    open_cluster(cluster, orig);
+}
+
 integration_test_guard::~integration_test_guard()
 {
     close_cluster(cluster);
     io_thread.join();
 }
 
-const couchbase::operations::management::bucket_describe_response::bucket_info&
+const couchbase::core::operations::management::bucket_describe_response::bucket_info&
 integration_test_guard::load_bucket_info(const std::string& bucket_name, bool refresh)
 {
     if (info.count(bucket_name) > 0 && !refresh) {
         return info[bucket_name];
     }
 
-    auto resp = execute(cluster, couchbase::operations::management::bucket_describe_request{ bucket_name });
-    if (resp.ctx.ec == couchbase::error::common_errc::service_not_available) {
+    auto resp = execute(cluster, couchbase::core::operations::management::bucket_describe_request{ bucket_name });
+    if (resp.ctx.ec == couchbase::errc::common::service_not_available) {
         open_bucket(cluster, ctx.bucket);
-        resp = execute(cluster, couchbase::operations::management::bucket_describe_request{ bucket_name });
+        resp = execute(cluster, couchbase::core::operations::management::bucket_describe_request{ bucket_name });
     }
     if (resp.ctx.ec) {
         LOG_CRITICAL("unable to load info for bucket \"{}\": {}", bucket_name, resp.ctx.ec.message());
@@ -66,17 +81,17 @@ integration_test_guard::load_bucket_info(const std::string& bucket_name, bool re
     return info[bucket_name];
 }
 
-const couchbase::operations::management::cluster_describe_response::cluster_info&
+const couchbase::core::operations::management::cluster_describe_response::cluster_info&
 integration_test_guard::load_cluster_info(bool refresh)
 {
     if (cluster_info && !refresh) {
         return cluster_info.value();
     }
 
-    auto resp = execute(cluster, couchbase::operations::management::cluster_describe_request{});
-    if (resp.ctx.ec == couchbase::error::common_errc::service_not_available) {
+    auto resp = execute(cluster, couchbase::core::operations::management::cluster_describe_request{});
+    if (resp.ctx.ec == couchbase::errc::common::service_not_available) {
         open_bucket(cluster, ctx.bucket);
-        resp = execute(cluster, couchbase::operations::management::cluster_describe_request{});
+        resp = execute(cluster, couchbase::core::operations::management::cluster_describe_request{});
     }
     if (resp.ctx.ec) {
         LOG_CRITICAL("unable to load info for cluster: {}", resp.ctx.ec.message());

package/deps/couchbase-transactions-cxx/deps/couchbase-cxx-client/test/utils/integration_test_guard.hxx

@@ -20,9 +20,9 @@
 #include "integration_shortcuts.hxx"
 #include "test_context.hxx"
 
-#include <couchbase/management/bucket_settings.hxx>
-#include <couchbase/operations/management/bucket_describe.hxx>
-#include <couchbase/operations/management/cluster_describe.hxx>
+#include "core/management/bucket_settings.hxx"
+#include "core/operations/management/bucket_describe.hxx"
+#include "core/operations/management/cluster_describe.hxx"
 
 #include <optional>
 
@@ -32,15 +32,16 @@ class integration_test_guard
 {
   public:
     integration_test_guard();
+    integration_test_guard(const couchbase::core::cluster_options& opts);
     ~integration_test_guard();
 
-    inline const couchbase::operations::management::bucket_describe_response::bucket_info& load_bucket_info(bool refresh = false)
+    inline const couchbase::core::operations::management::bucket_describe_response::bucket_info& load_bucket_info(bool refresh = false)
     {
         return load_bucket_info(ctx.bucket, refresh);
     }
 
-    const couchbase::operations::management::bucket_describe_response::bucket_info& load_bucket_info(const std::string& bucket_name,
-                                                                                                     bool refresh = false);
+    const couchbase::core::operations::management::bucket_describe_response::bucket_info& load_bucket_info(const std::string& bucket_name,
+                                                                                                           bool refresh = false);
 
     inline std::size_t number_of_nodes()
     {
@@ -62,26 +63,26 @@ class integration_test_guard
         return load_bucket_info(bucket_name).number_of_replicas;
     }
 
-    inline couchbase::management::cluster::bucket_storage_backend storage_backend()
+    inline couchbase::core::management::cluster::bucket_storage_backend storage_backend()
     {
         return load_bucket_info(ctx.bucket).storage_backend;
     }
 
-    const couchbase::operations::management::cluster_describe_response::cluster_info& load_cluster_info(bool refresh = false);
+    const couchbase::core::operations::management::cluster_describe_response::cluster_info& load_cluster_info(bool refresh = false);
 
-    inline bool has_service(couchbase::service_type service)
+    inline bool has_service(couchbase::core::service_type service)
     {
         return load_cluster_info().services.count(service) > 0;
     }
 
     inline bool has_eventing_service()
     {
-        return has_service(couchbase::service_type::eventing);
+        return has_service(couchbase::core::service_type::eventing);
     }
 
     inline bool has_analytics_service()
     {
-        return has_service(couchbase::service_type::analytics);
+        return has_service(couchbase::core::service_type::analytics);
     }
 
     auto number_of_query_nodes()
@@ -96,11 +97,11 @@ class integration_test_guard
 
     std::thread io_thread{};
     asio::io_context io{};
-    std::shared_ptr<couchbase::cluster> cluster;
+    std::shared_ptr<couchbase::core::cluster> cluster;
     test_context ctx;
-    couchbase::origin origin;
+    couchbase::core::origin origin;
 
-    std::map<std::string, couchbase::operations::management::bucket_describe_response::bucket_info, std::less<>> info{};
-    std::optional<couchbase::operations::management::cluster_describe_response::cluster_info> cluster_info{};
+    std::map<std::string, couchbase::core::operations::management::bucket_describe_response::bucket_info, std::less<>> info{};
+    std::optional<couchbase::core::operations::management::cluster_describe_response::cluster_info> cluster_info{};
 };
 } // namespace test::utils

package/deps/couchbase-transactions-cxx/deps/couchbase-cxx-client/test/utils/logger.cxx

@@ -15,9 +15,10 @@
  *   limitations under the License.
  */
 
-#include <couchbase/logger/logger.hxx>
+#include "core/logger/logger.hxx"
 
 #include <spdlog/details/os.h>
+#include <spdlog/spdlog.h>
 
 namespace test::utils
 {
@@ -27,10 +28,11 @@ init_logger()
     static bool initialized = false;
 
     if (!initialized) {
-        couchbase::logger::create_console_logger();
+        couchbase::core::logger::create_console_logger();
         if (auto env_val = spdlog::details::os::getenv("TEST_LOG_LEVEL"); !env_val.empty()) {
-            couchbase::logger::set_log_levels(couchbase::logger::level_from_str(env_val));
+            couchbase::core::logger::set_log_levels(couchbase::core::logger::level_from_str(env_val));
         }
+        spdlog::set_pattern("[%Y-%m-%d %T.%e] [%P,%t] [%^%l%$] %oms, %v at %@ %!");
         initialized = true;
     }
 }

package/deps/couchbase-transactions-cxx/deps/couchbase-cxx-client/test/utils/logger.hxx

@@ -21,4 +21,4 @@ namespace test::utils
 {
 void
 init_logger();
-}
+} // namespace test::utils

package/deps/couchbase-transactions-cxx/deps/couchbase-cxx-client/test/utils/server_version.hxx

@@ -114,7 +114,7 @@ struct server_version {
 
     [[nodiscard]] bool supports_analytics() const
     {
-        return is_enterprise() && (is_alice() || is_mad_hatter() || is_cheshire_cat() || is_neo());
+        return is_enterprise() && (is_mad_hatter() || is_cheshire_cat() || is_neo());
     }
 
     [[nodiscard]] bool supports_analytics_pending_mutations() const

package/deps/couchbase-transactions-cxx/deps/couchbase-cxx-client/test/utils/test_context.hxx

@@ -19,7 +19,7 @@
 
 #include "server_version.hxx"
 
-#include <couchbase/origin.hxx>
+#include "core/origin.hxx"
 
 #include <string>
 
@@ -35,9 +35,9 @@ struct test_context {
     server_version version{ 6, 6, 0 };
     deployment_type deployment{ deployment_type::on_prem };
 
-    [[nodiscard]] couchbase::cluster_credentials build_auth() const
+    [[nodiscard]] couchbase::core::cluster_credentials build_auth() const
     {
-        couchbase::cluster_credentials auth{};
+        couchbase::core::cluster_credentials auth{};
         if (certificate_path.empty()) {
             auth.username = username;
             auth.password = password;

package/deps/couchbase-transactions-cxx/deps/couchbase-cxx-client/test/utils/wait_until.cxx

@@ -20,10 +20,10 @@
 namespace test::utils
 {
 bool
-wait_until_bucket_healthy(std::shared_ptr<couchbase::cluster> cluster, const std::string& bucket_name)
+wait_until_bucket_healthy(std::shared_ptr<couchbase::core::cluster> cluster, const std::string& bucket_name)
 {
     return wait_until([cluster, bucket_name]() {
-        couchbase::operations::management::bucket_get_request req{ bucket_name };
+        couchbase::core::operations::management::bucket_get_request req{ bucket_name };
         auto resp = test::utils::execute(cluster, req);
         if (resp.ctx.ec) {
             return false;
@@ -41,12 +41,12 @@ wait_until_bucket_healthy(std::shared_ptr<couchbase::cluster> cluster, const std
 }
 
 bool
-wait_until_collection_manifest_propagated(std::shared_ptr<couchbase::cluster> cluster,
+wait_until_collection_manifest_propagated(std::shared_ptr<couchbase::core::cluster> cluster,
                                           const std::string& bucket_name,
                                           const std::uint64_t current_manifest_uid)
 {
     auto propagated = test::utils::wait_until([cluster, bucket_name, current_manifest_uid]() {
-        couchbase::operations::management::collections_manifest_get_request req{ { bucket_name, "_default", "_default", "" } };
+        couchbase::core::operations::management::collections_manifest_get_request req{ { bucket_name, "_default", "_default", "" } };
         auto resp = test::utils::execute(cluster, req);
         return resp.manifest.uid >= current_manifest_uid;
     });

package/deps/couchbase-transactions-cxx/deps/couchbase-cxx-client/test/utils/wait_until.hxx

@@ -20,9 +20,9 @@
 #include "integration_shortcuts.hxx"
 #include "server_version.hxx"
 
-#include <couchbase/cluster.hxx>
-#include <couchbase/operations/management/bucket.hxx>
-#include <couchbase/operations/management/collections.hxx>
+#include "core/cluster.hxx"
+#include "core/operations/management/bucket.hxx"
+#include "core/operations/management/collections.hxx"
 
 namespace test::utils
 {
@@ -55,10 +55,10 @@ wait_until(ConditionChecker&& condition_checker)
 }
 
 bool
-wait_until_bucket_healthy(std::shared_ptr<couchbase::cluster> cluster, const std::string& bucket_name);
+wait_until_bucket_healthy(std::shared_ptr<couchbase::core::cluster> cluster, const std::string& bucket_name);
 
 bool
-wait_until_collection_manifest_propagated(std::shared_ptr<couchbase::cluster> cluster,
+wait_until_collection_manifest_propagated(std::shared_ptr<couchbase::core::cluster> cluster,
                                           const std::string& bucket_name,
                                           const std::uint64_t current_manifest_uid);
 } // namespace test::utils

package/deps/couchbase-transactions-cxx/examples/game_server.cxx

@@ -19,7 +19,7 @@
 #include <random>
 #include <string>
 
-#include <couchbase/cluster.hxx>
+#include <core/cluster.hxx>
 #include <couchbase/transactions.hxx>
 #include <spdlog/spdlog.h>
 
@@ -133,8 +133,8 @@ class GameServer
 
     void player_hits_monster(const string&,
                              int damage_,
-                             const couchbase::document_id& player_id,
-                             const couchbase::document_id& monster_id,
+                             const core::document_id& player_id,
+                             const core::document_id& monster_id,
                              atomic<bool>& exists)
     {
         try {
@@ -191,16 +191,16 @@ int
 main(int, const char*[])
 {
     const int NUM_THREADS = 4;
-    couchbase::logger::set_log_levels(couchbase::logger::level::trace);
+    core::logger::set_log_levels(core::logger::level::trace);
     atomic<bool> monster_exists = true;
     string bucket_name = "default";
-    couchbase::cluster_credentials auth{};
+    core::cluster_credentials auth{};
     asio::io_context io;
-    auto cluster = couchbase::cluster::create(io);
-    if (!couchbase::logger::is_initialized()) {
-        couchbase::logger::create_console_logger();
+    auto cluster = core::cluster::create(io);
+    if (!core::logger::is_initialized()) {
+        core::logger::create_console_logger();
     }
-    couchbase::logger::set_log_levels(couchbase::logger::level::trace);
+    core::logger::set_log_levels(core::logger::level::trace);
 
     std::list<std::thread> io_threads;
     for (int i = 0; i < 2 * NUM_THREADS; i++) {
@@ -211,14 +211,14 @@ main(int, const char*[])
     std::mt19937 random_number_engine; // pseudorandom number generator
     auto rand = std::bind(hit_distribution, random_number_engine);
 
-    auto connstr = couchbase::utils::parse_connection_string("couchbase://127.0.0.1");
+    auto connstr = core::utils::parse_connection_string("couchbase://127.0.0.1");
     auth.username = "Administrator";
     auth.password = "password";
     // first, open it.
     {
         auto barrier = std::make_shared<std::promise<std::error_code>>();
         auto f = barrier->get_future();
-        cluster->open(couchbase::origin(auth, connstr), [barrier](std::error_code ec) { barrier->set_value(ec); });
+        cluster->open(core::origin(auth, connstr), [barrier](std::error_code ec) { barrier->set_value(ec); });
         auto rc = f.get();
         if (rc) {
             cout << "ERROR opening cluster: " << rc.message() << endl;
@@ -237,33 +237,33 @@ main(int, const char*[])
         }
     }
 
-    couchbase::document_id player_id = { "default", "_default", "_default", "player_data" };
+    core::document_id player_id = { "default", "_default", "_default", "player_data" };
     Player player_data{ 14248, 23832, "player", 141, true, "Jane", make_uuid() };
 
-    couchbase::document_id monster_id = { "default", "_default", "_default", "a_grue" };
+    core::document_id monster_id = { "default", "_default", "_default", "a_grue" };
     Monster monster_data{ 91, 40000, 0.19239324085462631, "monster", "Grue", make_uuid() };
 
     // upsert a player document
     {
-        couchbase::operations::upsert_request req{ player_id };
+        core::operations::upsert_request req{ player_id };
         nlohmann::json j;
         to_json(j, player_data);
-        req.value = couchbase::utils::to_binary(j.dump());
-        auto barrier = std::make_shared<std::promise<couchbase::operations::upsert_response>>();
-        cluster->execute(req, [barrier](couchbase::operations::upsert_response resp) { barrier->set_value(resp); });
+        req.value = core::utils::to_binary(j.dump());
+        auto barrier = std::make_shared<std::promise<core::operations::upsert_response>>();
+        cluster->execute(req, [barrier](core::operations::upsert_response resp) { barrier->set_value(resp); });
         auto f = barrier->get_future();
         auto resp = f.get();
-        cout << "Upserted sample player document: " << player_id.key() << "with cas:" << resp.cas.value << endl;
+        cout << "Upserted sample player document: " << player_id.key() << "with cas:" << resp.cas.value() << endl;
     }
     // upsert a monster document
     {
-        couchbase::operations::upsert_request req{ monster_id };
+        core::operations::upsert_request req{ monster_id };
         nlohmann::json j;
         to_json(j, monster_data);
-        req.value = couchbase::utils::to_binary(j.dump());
-        auto barrier = std::make_shared<std::promise<couchbase::operations::upsert_response>>();
+        req.value = core::utils::to_binary(j.dump());
+        auto barrier = std::make_shared<std::promise<core::operations::upsert_response>>();
         auto f = barrier->get_future();
-        cluster->execute(req, [barrier](couchbase::operations::upsert_response resp) { barrier->set_value(resp); });
+        cluster->execute(req, [barrier](core::operations::upsert_response resp) { barrier->set_value(resp); });
         auto resp = f.get();
         cout << "Upserted sample monster document: " << monster_id.key() << endl;
     }

package/deps/couchbase-transactions-cxx/include/couchbase/transactions/async_attempt_context.hxx

@@ -19,12 +19,14 @@
 #include <optional>
 #include <string>
 
-#include <couchbase/cluster.hxx>
-#include <couchbase/operations/document_query.hxx>
+#include <core/operations/document_query.hxx>
 #include <couchbase/transactions/exceptions.hxx>
 #include <couchbase/transactions/transaction_get_result.hxx>
 #include <couchbase/transactions/transaction_query_options.hxx>
 
+#include <couchbase/cluster.hxx>
+#include <couchbase/subdocument_error_context.hxx>
+
 namespace couchbase
 {
 namespace transactions
@@ -41,7 +43,7 @@ namespace transactions
       public:
         using Callback = std::function<void(std::exception_ptr, std::optional<transaction_get_result>)>;
         using VoidCallback = std::function<void(std::exception_ptr)>;
-        using QueryCallback = std::function<void(std::exception_ptr, std::optional<operations::query_response>)>;
+        using QueryCallback = std::function<void(std::exception_ptr, std::optional<core::operations::query_response>)>;
         virtual ~async_attempt_context() = default;
         /**
          * Gets a document from the specified Couchbase collection matching the specified id.
@@ -49,7 +51,7 @@ namespace transactions
          * @param id the document's ID
          * @param cb callback function with the result when successful, or a @ref transaction_operation_failed.
          */
-        virtual void get(const couchbase::document_id& id, Callback&& cb) = 0;
+        virtual void get(const core::document_id& id, Callback&& cb) = 0;
 
         /**
          * Gets a document from the specified Couchbase collection matching the specified id.
@@ -57,7 +59,7 @@ namespace transactions
          * @param id the document's ID
          * @param cb callback function with the result when successful, or a @ref transaction_operation_failed.
          */
-        virtual void get_optional(const couchbase::document_id& id, Callback&& cb) = 0;
+        virtual void get_optional(const core::document_id& id, Callback&& cb) = 0;
 
         /**
          * Mutates the specified document with new content, using the document's last TransactionDocument#cas().
@@ -96,7 +98,7 @@ namespace transactions
          *           successful, or @ref transaction_operation_failed
          */
         template<typename Content>
-        void insert(const couchbase::document_id& id, const Content& content, Callback&& cb)
+        void insert(const core::document_id& id, const Content& content, Callback&& cb)
         {
             return insert_raw(id, default_json_serializer::serialize(content), std::move(cb));
         }
@@ -159,7 +161,7 @@ namespace transactions
 
       protected:
         /** @internal */
-        virtual void insert_raw(const couchbase::document_id& id, const std::string& content, Callback&& cb) = 0;
+        virtual void insert_raw(const core::document_id& id, const std::string& content, Callback&& cb) = 0;
 
         /** @internal */
         virtual void replace_raw(const transaction_get_result& document, const std::string& content, Callback&& cb) = 0;

package/deps/couchbase-transactions-cxx/include/couchbase/transactions/attempt_context.hxx

@@ -18,7 +18,7 @@
 #include <optional>
 #include <string>
 
-#include <couchbase/cluster.hxx>
+#include <core/cluster.hxx>
 #include <couchbase/transactions/transaction_get_result.hxx>
 #include <couchbase/transactions/transaction_query_options.hxx>
 
@@ -49,7 +49,7 @@ namespace transactions
          * @throws transaction_operation_failed which either should not be caught by the lambda, or
          *         rethrown if it is caught.
          */
-        virtual transaction_get_result get(const couchbase::document_id& id) = 0;
+        virtual transaction_get_result get(const core::document_id& id) = 0;
 
         /**
          * Gets a document from the specified Couchbase collection matching the specified id.
@@ -62,7 +62,7 @@ namespace transactions
          * @throws transaction_operation_failed which either should not be caught by the lambda, or
          *         rethrown if it is caught.
          */
-        virtual std::optional<transaction_get_result> get_optional(const couchbase::document_id& id) = 0;
+        virtual std::optional<transaction_get_result> get_optional(const core::document_id& id) = 0;
 
         /**
          * Mutates the specified document with new content, using the document's last TransactionDocument#cas().
@@ -105,7 +105,7 @@ namespace transactions
          *         rethrown if it is caught.
          */
         template<typename Content>
-        transaction_get_result insert(const couchbase::document_id& id, const Content& content)
+        transaction_get_result insert(const core::document_id& id, const Content& content)
         {
             return insert_raw(id, default_json_serializer::serialize(content));
         }
@@ -131,14 +131,14 @@ namespace transactions
          * @param options options to apply to the query.
          * @returns result of the query.
          */
-        virtual operations::query_response query(const std::string& statement, const transaction_query_options& options) = 0;
+        virtual core::operations::query_response query(const std::string& statement, const transaction_query_options& options) = 0;
         /**
          * Performs a Query, within the current transaction.
          *
          * @param statement query statement to execute.
          * @return result of the query
          */
-        virtual operations::query_response query(const std::string& statement)
+        virtual core::operations::query_response query(const std::string& statement)
         {
             transaction_query_options opts;
             return query(statement, opts);
@@ -170,7 +170,7 @@ namespace transactions
 
       protected:
         /** @internal */
-        virtual transaction_get_result insert_raw(const couchbase::document_id& id, const std::string& content) = 0;
+        virtual transaction_get_result insert_raw(const core::document_id& id, const std::string& content) = 0;
 
         /** @internal */
         virtual transaction_get_result replace_raw(const transaction_get_result& document, const std::string& content) = 0;

package/deps/couchbase-transactions-cxx/include/couchbase/transactions/internal/atr_cleanup_entry.hxx

@@ -55,7 +55,7 @@ namespace transactions
         friend class transactions_cleanup_attempt;
 
       private:
-        couchbase::document_id atr_id_;
+        core::document_id atr_id_;
         std::string attempt_id_;
         std::chrono::time_point<std::chrono::steady_clock> min_start_time_;
         bool check_if_expired_;
@@ -85,13 +85,11 @@ namespace transactions
       public:
         explicit atr_cleanup_entry(attempt_context& ctx);
         explicit atr_cleanup_entry(const atr_entry& entry,
-                                   const couchbase::document_id& atr_coll,
+                                   const core::document_id& atr_coll,
                                    const transactions_cleanup& cleanup,
                                    bool check_if_expired = true);
 
-        explicit atr_cleanup_entry(const couchbase::document_id& atr_id,
-                                   const std::string& attempt_id,
-                                   const transactions_cleanup& cleanup);
+        explicit atr_cleanup_entry(const core::document_id& atr_id, const std::string& attempt_id, const transactions_cleanup& cleanup);
 
         void clean(std::shared_ptr<spdlog::logger> logger, transactions_cleanup_attempt* result = nullptr);
         bool ready() const;

package/deps/couchbase-transactions-cxx/include/couchbase/transactions/internal/doc_record.hxx

@@ -19,7 +19,7 @@
 #include <string>
 
 #include "transaction_fields.hxx"
-#include <couchbase/document_id.hxx>
+#include <core/document_id.hxx>
 #include <couchbase/internal/nlohmann/json.hpp>
 #include <couchbase/support.hxx>
 
@@ -49,7 +49,7 @@ namespace transactions
             return id_.collection();
         }
 
-        CB_NODISCARD const couchbase::document_id& document_id() const
+        CB_NODISCARD const core::document_id& document_id() const
         {
             return id_;
         }
@@ -76,7 +76,7 @@ namespace transactions
         }
 
       private:
-        couchbase::document_id id_;
+        core::document_id id_;
     };
 } // namespace transactions
 } // namespace couchbase

package/deps/couchbase-transactions-cxx/include/couchbase/transactions/internal/exceptions_internal.hxx

@@ -19,6 +19,7 @@
 #include "../../../../src/transactions/result.hxx"
 #include "couchbase/transactions/internal/transaction_context.hxx"
 #include <couchbase/transactions/exceptions.hxx>
+#include <list>
 
 namespace couchbase
 {

package/deps/couchbase-transactions-cxx/include/couchbase/transactions/internal/transaction_context.hxx

@@ -74,7 +74,7 @@ namespace transactions
 
         void add_attempt();
 
-        CB_NODISCARD couchbase::cluster& cluster_ref()
+        CB_NODISCARD core::cluster& cluster_ref()
         {
             return transactions_.cluster_ref();
         }
@@ -143,11 +143,11 @@ namespace transactions
         std::shared_ptr<attempt_context_impl> current_attempt_context();
 
         // These functions just delegate to the current_attempt_context_
-        void get(const couchbase::document_id& id, async_attempt_context::Callback&& cb);
+        void get(const core::document_id& id, async_attempt_context::Callback&& cb);
 
-        void get_optional(const couchbase::document_id& id, async_attempt_context::Callback&& cb);
+        void get_optional(const core::document_id& id, async_attempt_context::Callback&& cb);
 
-        void insert(const couchbase::document_id& id, const std::string& content, async_attempt_context::Callback&& cb);
+        void insert(const core::document_id& id, const std::string& content, async_attempt_context::Callback&& cb);
 
         void replace(const transaction_get_result& doc, const std::string& content, async_attempt_context::Callback&& cb);