couchbase 4.1.2 → 4.1.3

package/deps/couchbase-cxx-client/test/utils/integration_shortcuts.cxx

@@ -17,12 +17,12 @@
 
 #include "integration_shortcuts.hxx"
 
-#include <couchbase/utils/join_strings.hxx>
+#include "core/utils/join_strings.hxx"
 
 namespace test::utils
 {
 void
-open_cluster(std::shared_ptr<couchbase::cluster> cluster, const couchbase::origin& origin)
+open_cluster(std::shared_ptr<couchbase::core::cluster> cluster, const couchbase::core::origin& origin)
 {
     auto barrier = std::make_shared<std::promise<std::error_code>>();
     auto f = barrier->get_future();
@@ -30,12 +30,12 @@ open_cluster(std::shared_ptr<couchbase::cluster> cluster, const couchbase::origi
     auto rc = f.get();
     if (rc) {
         LOG_CRITICAL(
-          "unable to connect to the cluster: {}, nodes={}", rc.message(), couchbase::utils::join_strings(origin.get_nodes(), ", "));
+          "unable to connect to the cluster: {}, nodes={}", rc.message(), couchbase::core::utils::join_strings(origin.get_nodes(), ", "));
         throw std::system_error(rc);
     }
 }
 void
-close_cluster(std::shared_ptr<couchbase::cluster> cluster)
+close_cluster(std::shared_ptr<couchbase::core::cluster> cluster)
 {
     auto barrier = std::make_shared<std::promise<void>>();
     auto f = barrier->get_future();
@@ -44,7 +44,7 @@ close_cluster(std::shared_ptr<couchbase::cluster> cluster)
 }
 
 void
-open_bucket(std::shared_ptr<couchbase::cluster> cluster, const std::string& bucket_name)
+open_bucket(std::shared_ptr<couchbase::core::cluster> cluster, const std::string& bucket_name)
 {
     auto barrier = std::make_shared<std::promise<std::error_code>>();
     auto f = barrier->get_future();
@@ -57,7 +57,7 @@ open_bucket(std::shared_ptr<couchbase::cluster> cluster, const std::string& buck
 }
 
 void
-close_bucket(std::shared_ptr<couchbase::cluster> cluster, const std::string& bucket_name)
+close_bucket(std::shared_ptr<couchbase::core::cluster> cluster, const std::string& bucket_name)
 {
     auto barrier = std::make_shared<std::promise<std::error_code>>();
     auto f = barrier->get_future();

package/deps/couchbase-cxx-client/test/utils/integration_shortcuts.hxx

@@ -17,31 +17,30 @@
 
 #pragma once
 
-#include <couchbase/cluster.hxx>
+#include "core/cluster.hxx"
 
 namespace test::utils
 {
 template<class Request>
 auto
-execute(std::shared_ptr<couchbase::cluster> cluster, Request request)
+execute(std::shared_ptr<couchbase::core::cluster> cluster, Request request)
 {
     using response_type = typename Request::response_type;
     auto barrier = std::make_shared<std::promise<response_type>>();
     auto f = barrier->get_future();
     cluster->execute(request, [barrier](response_type resp) { barrier->set_value(std::move(resp)); });
-    auto resp = f.get();
-    return resp;
+    return std::move(f.get());
 }
 
 void
-open_cluster(std::shared_ptr<couchbase::cluster> cluster, const couchbase::origin& origin);
+open_cluster(std::shared_ptr<couchbase::core::cluster> cluster, const couchbase::core::origin& origin);
 
 void
-close_cluster(std::shared_ptr<couchbase::cluster> cluster);
+close_cluster(std::shared_ptr<couchbase::core::cluster> cluster);
 
 void
-open_bucket(std::shared_ptr<couchbase::cluster> cluster, const std::string& bucket_name);
+open_bucket(std::shared_ptr<couchbase::core::cluster> cluster, const std::string& bucket_name);
 
 void
-close_bucket(std::shared_ptr<couchbase::cluster> cluster, const std::string& bucket_name);
+close_bucket(std::shared_ptr<couchbase::core::cluster> cluster, const std::string& bucket_name);
 } // namespace test::utils

package/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-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-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-cxx-client/test/utils/logger.hxx

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

package/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-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-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-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/deps/couchbase-cxx-client/.github/workflows/tests.yml

@@ -11,7 +11,7 @@ jobs:
     strategy:
       matrix:
         server:
-          - 7.1.0
+          - 7.1.1
           - 7.0.3
           - 6.6.5
     runs-on: ubuntu-20.04

package/deps/couchbase-transactions-cxx/deps/couchbase-cxx-client/.idea/misc.xml

@@ -3,6 +3,7 @@
   <component name="CMakeWorkspace" PROJECT_DIR="$PROJECT_DIR$" />
   <component name="CidrRootsConfiguration">
     <sourceRoots>
+      <file path="$PROJECT_DIR$/core" />
       <file path="$PROJECT_DIR$/couchbase" />
     </sourceRoots>
     <libraryRoots>

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

@@ -68,24 +68,209 @@ include(cmake/OpenSSL.cmake)
 
 include(cmake/VersionInfo.cmake)
 
-add_subdirectory(couchbase/meta)
-add_subdirectory(couchbase/platform)
-add_subdirectory(couchbase/logger)
-add_subdirectory(couchbase/crypto)
-add_subdirectory(couchbase/sasl)
-add_subdirectory(couchbase/topology)
-add_subdirectory(couchbase/utils)
-add_subdirectory(couchbase/protocol)
-add_subdirectory(couchbase/io)
-add_subdirectory(couchbase/management)
-add_subdirectory(couchbase/operations)
-add_subdirectory(couchbase/tracing)
-add_subdirectory(couchbase/metrics)
+add_subdirectory(core/meta)
+add_subdirectory(core/platform)
+add_subdirectory(core/logger)
+add_subdirectory(core/crypto)
+add_subdirectory(core/sasl)
+add_subdirectory(core/io)
+add_subdirectory(core/tracing)
+add_subdirectory(core/metrics)
+
+set(couchbase_cxx_client_FILES
+    core/cluster.cxx
+    core/cluster_options.cxx
+    core/document_id.cxx
+    core/error_context/key_value.cxx
+    core/management/analytics_link_azure_blob_external.cxx
+    core/management/analytics_link_couchbase_remote.cxx
+    core/management/analytics_link_s3_external.cxx
+    core/operations/document_analytics.cxx
+    core/operations/document_append.cxx
+    core/operations/document_decrement.cxx
+    core/operations/document_exists.cxx
+    core/operations/document_get.cxx
+    core/operations/document_get_and_lock.cxx
+    core/operations/document_get_and_touch.cxx
+    core/operations/document_get_projected.cxx
+    core/operations/document_increment.cxx
+    core/operations/document_insert.cxx
+    core/operations/document_lookup_in.cxx
+    core/operations/document_mutate_in.cxx
+    core/operations/document_prepend.cxx
+    core/operations/document_query.cxx
+    core/operations/document_remove.cxx
+    core/operations/document_replace.cxx
+    core/operations/document_search.cxx
+    core/operations/document_touch.cxx
+    core/operations/document_unlock.cxx
+    core/operations/document_upsert.cxx
+    core/operations/document_view.cxx
+    core/operations/http_noop.cxx
+    core/operations/management/analytics_dataset_create.cxx
+    core/operations/management/analytics_dataset_drop.cxx
+    core/operations/management/analytics_dataset_get_all.cxx
+    core/operations/management/analytics_dataverse_create.cxx
+    core/operations/management/analytics_dataverse_drop.cxx
+    core/operations/management/analytics_get_pending_mutations.cxx
+    core/operations/management/analytics_index_create.cxx
+    core/operations/management/analytics_index_drop.cxx
+    core/operations/management/analytics_index_get_all.cxx
+    core/operations/management/analytics_link_connect.cxx
+    core/operations/management/analytics_link_create.cxx
+    core/operations/management/analytics_link_disconnect.cxx
+    core/operations/management/analytics_link_drop.cxx
+    core/operations/management/analytics_link_get_all.cxx
+    core/operations/management/analytics_link_replace.cxx
+    core/operations/management/bucket_create.cxx
+    core/operations/management/bucket_describe.cxx
+    core/operations/management/bucket_drop.cxx
+    core/operations/management/bucket_flush.cxx
+    core/operations/management/bucket_get.cxx
+    core/operations/management/bucket_get_all.cxx
+    core/operations/management/bucket_update.cxx
+    core/operations/management/cluster_describe.cxx
+    core/operations/management/cluster_developer_preview_enable.cxx
+    core/operations/management/collection_create.cxx
+    core/operations/management/collection_drop.cxx
+    core/operations/management/collections_manifest_get.cxx
+    core/operations/management/error_utils.cxx
+    core/operations/management/eventing_deploy_function.cxx
+    core/operations/management/eventing_drop_function.cxx
+    core/operations/management/eventing_get_all_functions.cxx
+    core/operations/management/eventing_get_function.cxx
+    core/operations/management/eventing_get_status.cxx
+    core/operations/management/eventing_pause_function.cxx
+    core/operations/management/eventing_resume_function.cxx
+    core/operations/management/eventing_undeploy_function.cxx
+    core/operations/management/eventing_upsert_function.cxx
+    core/operations/management/freeform.cxx
+    core/operations/management/group_drop.cxx
+    core/operations/management/group_get.cxx
+    core/operations/management/group_get_all.cxx
+    core/operations/management/group_upsert.cxx
+    core/operations/management/query_index_build.cxx
+    core/operations/management/query_index_create.cxx
+    core/operations/management/query_index_drop.cxx
+    core/operations/management/query_index_get_all.cxx
+    core/operations/management/query_index_get_all_deferred.cxx
+    core/operations/management/role_get_all.cxx
+    core/operations/management/scope_create.cxx
+    core/operations/management/scope_drop.cxx
+    core/operations/management/scope_get_all.cxx
+    core/operations/management/search_get_stats.cxx
+    core/operations/management/search_index_analyze_document.cxx
+    core/operations/management/search_index_control_ingest.cxx
+    core/operations/management/search_index_control_plan_freeze.cxx
+    core/operations/management/search_index_control_query.cxx
+    core/operations/management/search_index_drop.cxx
+    core/operations/management/search_index_get.cxx
+    core/operations/management/search_index_get_all.cxx
+    core/operations/management/search_index_get_documents_count.cxx
+    core/operations/management/search_index_get_stats.cxx
+    core/operations/management/search_index_upsert.cxx
+    core/operations/management/user_drop.cxx
+    core/operations/management/user_get.cxx
+    core/operations/management/user_get_all.cxx
+    core/operations/management/user_upsert.cxx
+    core/operations/management/view_index_drop.cxx
+    core/operations/management/view_index_get.cxx
+    core/operations/management/view_index_get_all.cxx
+    core/operations/management/view_index_upsert.cxx
+    core/operations/mcbp_noop.cxx
+    core/protocol/client_request.cxx
+    core/protocol/client_response.cxx
+    core/protocol/cmd_append.cxx
+    core/protocol/cmd_cluster_map_change_notification.cxx
+    core/protocol/cmd_decrement.cxx
+    core/protocol/cmd_get.cxx
+    core/protocol/cmd_get_and_lock.cxx
+    core/protocol/cmd_get_and_touch.cxx
+    core/protocol/cmd_get_cluster_config.cxx
+    core/protocol/cmd_get_collection_id.cxx
+    core/protocol/cmd_get_collections_manifest.cxx
+    core/protocol/cmd_get_error_map.cxx
+    core/protocol/cmd_get_meta.cxx
+    core/protocol/cmd_get_replica.cxx
+    core/protocol/cmd_hello.cxx
+    core/protocol/cmd_increment.cxx
+    core/protocol/cmd_insert.cxx
+    core/protocol/cmd_lookup_in.cxx
+    core/protocol/cmd_mutate_in.cxx
+    core/protocol/cmd_noop.cxx
+    core/protocol/cmd_observe_seqno.cxx
+    core/protocol/cmd_prepend.cxx
+    core/protocol/cmd_remove.cxx
+    core/protocol/cmd_replace.cxx
+    core/protocol/cmd_sasl_auth.cxx
+    core/protocol/cmd_sasl_list_mechs.cxx
+    core/protocol/cmd_sasl_step.cxx
+    core/protocol/cmd_select_bucket.cxx
+    core/protocol/cmd_touch.cxx
+    core/protocol/cmd_unlock.cxx
+    core/protocol/cmd_upsert.cxx
+    core/protocol/frame_info_utils.cxx
+    core/protocol/status.cxx
+    core/topology/configuration.cxx
+    core/utils/binary.cxx
+    core/utils/connection_string.cxx
+    core/utils/duration_parser.cxx
+    core/utils/json.cxx
+    core/utils/json_streaming_lexer.cxx
+    core/utils/mutation_token.cxx
+    core/utils/url_codec.cxx
+    core/impl/analytics_error_category.cxx
+    core/impl/append.cxx
+    core/impl/build_deferred_query_indexes.cxx
+    core/impl/common_error_category.cxx
+    core/impl/decrement.cxx
+    core/impl/expiry.cxx
+    core/impl/field_level_encryption_error_category.cxx
+    core/impl/get.cxx
+    core/impl/get_all_replicas.cxx
+    core/impl/get_and_touch.cxx
+    core/impl/get_any_replica.cxx
+    core/impl/get_replica.cxx
+    core/impl/increment.cxx
+    core/impl/insert.cxx
+    core/impl/key_value_error_category.cxx
+    core/impl/lookup_in.cxx
+    core/impl/management_error_category.cxx
+    core/impl/mutate_in.cxx
+    core/impl/network_error_category.cxx
+    core/impl/observe_poll.cxx
+    core/impl/observe_seqno.cxx
+    core/impl/prepend.cxx
+    core/impl/query_error_category.cxx
+    core/impl/remove.cxx
+    core/impl/replace.cxx
+    core/impl/search_error_category.cxx
+    core/impl/streaming_json_lexter_error_category.cxx
+    core/impl/subdoc/array_add_unique.cxx
+    core/impl/subdoc/array_append.cxx
+    core/impl/subdoc/array_insert.cxx
+    core/impl/subdoc/array_prepend.cxx
+    core/impl/subdoc/count.cxx
+    core/impl/subdoc/counter.cxx
+    core/impl/subdoc/exists.cxx
+    core/impl/subdoc/get.cxx
+    core/impl/subdoc/insert.cxx
+    core/impl/subdoc/join_values.cxx
+    core/impl/subdoc/lookup_in_macro.cxx
+    core/impl/subdoc/lookup_in_specs.cxx
+    core/impl/subdoc/mutate_in_macro.cxx
+    core/impl/subdoc/mutate_in_specs.cxx
+    core/impl/subdoc/remove.cxx
+    core/impl/subdoc/replace.cxx
+    core/impl/subdoc/upsert.cxx
+    core/impl/touch.cxx
+    core/impl/upsert.cxx
+    core/impl/view_error_category.cxx)
 
 if(COUCHBASE_CXX_CLIENT_BUILD_SHARED)
-  add_library(couchbase_cxx_client SHARED couchbase/cluster.cxx couchbase/document_id.cxx couchbase/cluster_options.cxx)
+  add_library(couchbase_cxx_client SHARED ${couchbase_cxx_client_FILES})
 else()
-  add_library(couchbase_cxx_client STATIC couchbase/cluster.cxx couchbase/document_id.cxx couchbase/cluster_options.cxx)
+  add_library(couchbase_cxx_client STATIC ${couchbase_cxx_client_FILES})
 endif()
 set_target_properties(couchbase_cxx_client PROPERTIES POSITION_INDEPENDENT_CODE ON)
 target_include_directories(couchbase_cxx_client PUBLIC ${PROJECT_SOURCE_DIR})
@@ -117,6 +302,9 @@ target_link_libraries(
   couchbase_cxx_client
   PUBLIC fmt::fmt
          spdlog::spdlog
+         snappy
+         jsonsl
+         hdr_histogram_static
          couchbase_backtrace
          couchbase_logger
          couchbase_platform
@@ -124,12 +312,6 @@ target_link_libraries(
          couchbase_meta
          couchbase_crypto
          couchbase_sasl
-         couchbase_topology
-         couchbase_utils
-         couchbase_protocol
-         couchbase_management
-         couchbase_operations
-         couchbase_operations_management
          couchbase_tracing
          couchbase_metrics)
 if(NOT COUCHBASE_CXX_CLIENT_POST_LINKED_OPENSSL)
@@ -140,3 +322,8 @@ option(COUCHBASE_CXX_CLIENT_BUILD_TESTS "Build test programs" TRUE)
 if(COUCHBASE_CXX_CLIENT_BUILD_TESTS)
   include(cmake/Testing.cmake)
 endif()
+
+option(COUCHBASE_CXX_CLIENT_BUILD_DOCS "Build API documentation" TRUE)
+if(COUCHBASE_CXX_CLIENT_BUILD_DOCS)
+  include(cmake/Documentation.cmake)
+endif()

package/deps/couchbase-transactions-cxx/deps/couchbase-cxx-client/CODE_OF_CONDUCT.md

@@ -0,0 +1,4 @@
+# Code of Conduct
+
+Please refer to the [Couchbase Community Guidelines](https://www.couchbase.com/community-guidelines)
+which applies to community members as well as employees.