couchbase 4.0.0 → 4.1.2

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

@@ -77,6 +77,7 @@ 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)
@@ -100,7 +101,12 @@ target_include_directories(
 target_link_libraries(couchbase_cxx_client PRIVATE project_options project_warnings)
 
 include(cmake/DetectStandardFilesystem.cmake)
-couchbase_cxx_check_filesystem(couchbase_cxx_client "filesystem" "std::filesystem" "stdc++fs;c++fs" STD_FILESYSTEM)
+couchbase_cxx_check_filesystem(
+  couchbase_cxx_client
+  "filesystem"
+  "std::filesystem"
+  "stdc++fs;c++fs"
+  STD_FILESYSTEM)
 if(STD_FILESYSTEM)
   message(STATUS "Using std::filesystem")
 else()
@@ -121,6 +127,7 @@ target_link_libraries(
          couchbase_topology
          couchbase_utils
          couchbase_protocol
+         couchbase_management
          couchbase_operations
          couchbase_operations_management
          couchbase_tracing

package/deps/couchbase-transactions-cxx/deps/couchbase-cxx-client/bin/build-tests

@@ -32,12 +32,14 @@ CB_CC=${CB_CC:-$(which ${CB_DEFAULT_CC})}
 CB_CXX=${CB_CXX:-$(which ${CB_DEFAULT_CXX})}
 CB_NUMBER_OF_JOBS=${CB_NUMBER_OF_JOBS:-1}
 CB_CMAKE_BUILD_TYPE=${CB_CMAKE_BUILD_TYPE:-Debug}
+CB_CACHE_OPTION=${CB_CACHE_OPTION:-ccache}
 
 echo "CB_CMAKE=${CB_CMAKE}"
 echo "CB_CC=${CB_CC}"
 echo "CB_CXX=${CB_CXX}"
 echo "CB_NUMBER_OF_JOBS=${CB_NUMBER_OF_JOBS}"
 echo "CB_CMAKE_BUILD_TYPE=${CB_CMAKE_BUILD_TYPE}"
+echo "CB_CACHE_OPTION=${CB_CACHE_OPTION}"
 
 CB_CMAKE_EXTRAS=
 case "${CB_SANITIZER}" in
@@ -79,6 +81,7 @@ ${CB_CMAKE}  \
     -DCMAKE_CXX_COMPILER="${CB_CXX}" \
     -DCOUCHBASE_CXX_CLIENT_BUILD_TESTS=ON \
     -DCOUCHBASE_CXX_CLIENT_BUILD_SHARED=ON \
+    -DCACHE_OPTION="${CB_CACHE_OPTION}" \
     ${CB_CMAKE_EXTRAS} \
     -B "${BUILD_DIR}" \
     -S "${PROJECT_ROOT}"

package/deps/couchbase-transactions-cxx/deps/couchbase-cxx-client/bin/build-tests.rb

@@ -48,6 +48,7 @@ CB_CC = ENV.fetch("CB_CC", which(CB_DEFAULT_CC))
 CB_CXX = ENV.fetch("CB_CXX", which(CB_DEFAULT_CXX))
 CB_NUMBER_OF_JOBS = ENV.fetch("CB_NUMBER_OF_JOBS", "1").to_i
 CB_CMAKE_BUILD_TYPE = ENV.fetch("CB_CMAKE_BUILD_TYPE", "Debug")
+CB_CACHE_OPTION = ENV.fetch("CB_CACHE_OPTION", "ccache")
 
 puts "RUBY_PLATFORM=#{RUBY_PLATFORM}"
 puts "CB_CMAKE=#{CB_CMAKE}"
@@ -58,6 +59,7 @@ if RUBY_PLATFORM !~ /mswin|mingw/
   puts "CB_CC=#{CB_CC}"
   puts "CB_CXX=#{CB_CXX}"
 end
+puts "CB_CACHE_OPTION=#{CB_CACHE_OPTION}"
 
 CB_CMAKE_EXTRAS = []
 case CB_SANITIZER
@@ -91,6 +93,7 @@ Dir.chdir(BUILD_DIR) do
   run(CB_CMAKE,
       "-DCMAKE_BUILD_TYPE=#{CB_CMAKE_BUILD_TYPE}",
       "-DCOUCHBASE_CXX_CLIENT_BUILD_TESTS=ON",
+      "-DCACHE_OPTION=#{CB_CACHE_OPTION}",
       *CB_CMAKE_EXTRAS,
       "-B", BUILD_DIR,
       "-S", PROJECT_ROOT)

package/deps/couchbase-transactions-cxx/deps/couchbase-cxx-client/bin/init-cluster

@@ -30,7 +30,7 @@ options = {
   username: ENV.fetch("CB_USERNAME", "Administrator"),
   password: ENV.fetch("CB_PASSWORD", "password"),
   bucket: ENV.fetch("CB_BUCKET", "default"),
-  server_quota: ENV.fetch("CB_SERVER_QUOTA", 1024).to_i,
+  server_quota: ENV.fetch("CB_SERVER_QUOTA", 2048).to_i,
   index_quota: ENV.fetch("CB_INDEX_QUOTA", 256).to_i,
   bucket_quota: ENV.fetch("CB_BUCKET_QUOTA", 256).to_i,
   enable_developer_preview: ENV.fetch("CB_DEVELOPER_PREVIEW", false).to_b,

package/deps/couchbase-transactions-cxx/deps/couchbase-cxx-client/bin/run-tests

@@ -30,4 +30,4 @@ fi
 
 cd "${BUILD_DIR}"
 
-${CB_CTEST} --output-on-failure --label-regex 'integration|unit'
+${CB_CTEST} --output-on-failure --label-regex 'integration|unit' --output-junit results.xml

package/deps/couchbase-transactions-cxx/deps/couchbase-cxx-client/cmake/CompilerWarnings.cmake

@@ -7,6 +7,7 @@ function(set_project_warnings project_name)
 
   set(MSVC_WARNINGS
       /W4 # Baseline reasonable warnings
+      /wd4189 # 'identifier': local variable is initialized but not referenced
       /wd4242 # 'identifier': conversion from 'type1' to 'type1', possible loss of data
       /wd4244 # 'identifier': conversion from 'type1' to 'type1', possible loss of data
       /w14254 # 'operator': conversion from 'type1:field_bits' to 'type2:field_bits', possible loss of data

package/deps/couchbase-transactions-cxx/deps/couchbase-cxx-client/cmake/OpenSSL.cmake

@@ -1,4 +1,5 @@
 option(COUCHBASE_CXX_CLIENT_POST_LINKED_OPENSSL "Rely on application to link OpenSSL library" FALSE)
+option(COUCHBASE_CXX_CLIENT_USE_HOMEBREW_TO_DETECT_OPENSSL "Use homebrew to determine OpenSSL root directory" TRUE)
 
 if(COUCHBASE_CXX_CLIENT_POST_LINKED_OPENSSL)
   message(
@@ -9,6 +10,13 @@ else()
   if(COUCHBASE_CXX_CLIENT_STATIC_OPENSSL)
     set(OPENSSL_USE_STATIC_LIBS ON)
   endif()
+  if(APPLE AND COUCHBASE_CXX_CLIENT_USE_HOMEBREW_TO_DETECT_OPENSSL)
+    execute_process(
+      COMMAND brew --prefix openssl@1.1
+      OUTPUT_VARIABLE OPENSSL_ROOT_DIR
+      OUTPUT_STRIP_TRAILING_WHITESPACE)
+    message(STATUS "Found OpenSSL prefix using homebrew: ${OPENSSL_ROOT_DIR}")
+  endif()
   include(FindOpenSSL)
   if(OPENSSL_LIBRARIES AND OPENSSL_INCLUDE_DIR)
     message(STATUS "OPENSSL_VERSION: ${OPENSSL_VERSION}")

package/deps/couchbase-transactions-cxx/deps/couchbase-cxx-client/cmake/StandardProjectSettings.cmake

@@ -39,7 +39,7 @@ else()
   message(STATUS "No colored compiler diagnostic set for '${CMAKE_CXX_COMPILER_ID}' compiler.")
 endif()
 
-if(WIN32)
+if(MSVC)
   add_definitions(/bigobj)
 endif()
 

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

@@ -0,0 +1,26 @@
+/* -*- Mode: C++; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */
+/*
+ *   Copyright 2020-2021 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
+
+namespace couchbase
+{
+enum class analytics_scan_consistency {
+    not_bounded = 0,
+    request_plus,
+};
+} // namespace couchbase

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

@@ -0,0 +1,43 @@
+/* -*- Mode: C++; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */
+/*
+ *   Copyright 2020-2021 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
+
+namespace couchbase::default_ca
+{
+
+static const char* capellaCaCert = "-----BEGIN CERTIFICATE-----\n"
+                                   "MIIDFTCCAf2gAwIBAgIRANLVkgOvtaXiQJi0V6qeNtswDQYJKoZIhvcNAQELBQAw\n"
+                                   "JDESMBAGA1UECgwJQ291Y2hiYXNlMQ4wDAYDVQQLDAVDbG91ZDAeFw0xOTEyMDYy\n"
+                                   "MjEyNTlaFw0yOTEyMDYyMzEyNTlaMCQxEjAQBgNVBAoMCUNvdWNoYmFzZTEOMAwG\n"
+                                   "A1UECwwFQ2xvdWQwggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQCfvOIi\n"
+                                   "enG4Dp+hJu9asdxEMRmH70hDyMXv5ZjBhbo39a42QwR59y/rC/sahLLQuNwqif85\n"
+                                   "Fod1DkqgO6Ng3vecSAwyYVkj5NKdycQu5tzsZkghlpSDAyI0xlIPSQjoORA/pCOU\n"
+                                   "WOpymA9dOjC1bo6rDyw0yWP2nFAI/KA4Z806XeqLREuB7292UnSsgFs4/5lqeil6\n"
+                                   "rL3ooAw/i0uxr/TQSaxi1l8t4iMt4/gU+W52+8Yol0JbXBTFX6itg62ppb/Eugmn\n"
+                                   "mQRMgL67ccZs7cJ9/A0wlXencX2ohZQOR3mtknfol3FH4+glQFn27Q4xBCzVkY9j\n"
+                                   "KQ20T1LgmGSngBInAgMBAAGjQjBAMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYE\n"
+                                   "FJQOBPvrkU2In1Sjoxt97Xy8+cKNMA4GA1UdDwEB/wQEAwIBhjANBgkqhkiG9w0B\n"
+                                   "AQsFAAOCAQEARgM6XwcXPLSpFdSf0w8PtpNGehmdWijPM3wHb7WZiS47iNen3oq8\n"
+                                   "m2mm6V3Z57wbboPpfI+VEzbhiDcFfVnK1CXMC0tkF3fnOG1BDDvwt4jU95vBiNjY\n"
+                                   "xdzlTP/Z+qr0cnVbGBSZ+fbXstSiRaaAVcqQyv3BRvBadKBkCyPwo+7svQnScQ5P\n"
+                                   "Js7HEHKVms5tZTgKIw1fbmgR2XHleah1AcANB+MAPBCcTgqurqr5G7W2aPSBLLGA\n"
+                                   "fRIiVzm7VFLc7kWbp7ENH39HVG6TZzKnfl9zJYeiklo5vQQhGSMhzBsO70z4RRzi\n"
+                                   "DPFAN/4qZAgD5q3AFNIq2WWADFQGSwVJhg==\n"
+                                   "-----END CERTIFICATE-----\n";
+
+} // namespace couchbase::default_ca

package/deps/{couchbase-cxx-client/couchbase/protocol → couchbase-transactions-cxx/deps/couchbase-cxx-client/couchbase}/cas.hxx

@@ -19,7 +19,7 @@
 
 #include <cstdint>
 
-namespace couchbase::protocol
+namespace couchbase
 {
 /**
  * CAS is a special type that represented in protocol using unsigned 64-bit integer, but only equality checks allowed.
@@ -44,4 +44,4 @@ struct cas {
         return value == 0;
     }
 };
-} // namespace couchbase::protocol
+} // namespace couchbase

package/deps/couchbase-transactions-cxx/deps/couchbase-cxx-client/couchbase/{protocol/cas_fmt.hxx → cas_fmt.hxx}

@@ -17,12 +17,12 @@
 
 #pragma once
 
-#include <couchbase/protocol/cas.hxx>
+#include <couchbase/cas.hxx>
 
 #include <fmt/core.h>
 
 template<>
-struct fmt::formatter<couchbase::protocol::cas> {
+struct fmt::formatter<couchbase::cas> {
     template<typename ParseContext>
     constexpr auto parse(ParseContext& ctx)
     {
@@ -30,7 +30,7 @@ struct fmt::formatter<couchbase::protocol::cas> {
     }
 
     template<typename FormatContext>
-    auto format(const couchbase::protocol::cas& cas, FormatContext& ctx) const
+    auto format(const couchbase::cas& cas, FormatContext& ctx) const
     {
         return format_to(ctx.out(), "{:x}", cas.value);
     }

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

@@ -28,7 +28,7 @@ class ping_collector : public std::enable_shared_from_this<ping_collector>
 
   public:
     ping_collector(std::string report_id, utils::movable_function<void(diag::ping_result)>&& handler)
-      : res_{ std::move(report_id), couchbase::meta::sdk_id() }
+      : res_{ std::move(report_id), meta::sdk_id() }
       , handler_(std::move(handler))
     {
     }
@@ -45,7 +45,7 @@ class ping_collector : public std::enable_shared_from_this<ping_collector>
 
     auto build_reporter()
     {
-        expected_++;
+        ++expected_;
         return [self = this->shared_from_this()](diag::endpoint_ping_info&& info) {
             std::scoped_lock lock(self->mutex_);
             self->res_.services[info.type].emplace_back(std::move(info));
@@ -74,27 +74,40 @@ cluster::do_ping(std::optional<std::string> report_id,
         report_id = std::make_optional(uuid::to_string(uuid::random()));
     }
     if (stopped_) {
-        return handler({ report_id.value(), couchbase::meta::sdk_id() });
+        return handler({ report_id.value(), meta::sdk_id() });
     }
     if (services.empty()) {
-        services = { service_type::key_value, service_type::view, service_type::query, service_type::search, service_type::analytics };
+        services = {
+            service_type::key_value, service_type::view,       service_type::query,    service_type::search,
+            service_type::analytics, service_type::management, service_type::eventing,
+        };
     }
-    asio::post(asio::bind_executor(ctx_, [this, report_id, bucket_name, services, handler = std::move(handler)]() mutable {
-        auto collector = std::make_shared<ping_collector>(report_id.value(), std::move(handler));
-        if (bucket_name) {
-            if (services.find(service_type::key_value) != services.end()) {
-                for_each_bucket([&collector](auto& bucket) { bucket->ping(collector); });
-            }
-        } else {
-            if (services.find(service_type::key_value) != services.end()) {
-                if (session_) {
-                    session_->ping(collector->build_reporter());
-                }
-                for_each_bucket([&collector](auto& bucket) { bucket->ping(collector); });
-            }
-            session_manager_->ping(services, collector, origin_.credentials());
-        }
-    }));
+    asio::post(
+      asio::bind_executor(ctx_, [cluster = shared_from_this(), report_id, bucket_name, services, handler = std::move(handler)]() mutable {
+          auto collector = std::make_shared<ping_collector>(report_id.value(), std::move(handler));
+          if (bucket_name) {
+              if (services.find(service_type::key_value) != services.end()) {
+                  if (auto bucket = cluster->find_bucket_by_name(bucket_name.value()); bucket) {
+                      return bucket->ping(collector);
+                  }
+                  cluster->open_bucket(bucket_name.value(), [collector, cluster, bucket_name](std::error_code ec) {
+                      if (!ec) {
+                          if (auto bucket = cluster->find_bucket_by_name(bucket_name.value()); bucket) {
+                              return bucket->ping(collector);
+                          }
+                      }
+                  });
+              }
+          } else {
+              if (services.find(service_type::key_value) != services.end()) {
+                  if (cluster->session_) {
+                      cluster->session_->ping(collector->build_reporter());
+                  }
+                  cluster->for_each_bucket([&collector](auto& bucket) { bucket->ping(collector); });
+              }
+              cluster->session_manager_->ping(services, collector, cluster->origin_.credentials());
+          }
+      }));
 }
 
 std::shared_ptr<bucket>

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

@@ -18,6 +18,7 @@
 #pragma once
 
 #include <couchbase/bucket.hxx>
+#include <couchbase/capella_ca.hxx>
 #include <couchbase/diagnostics.hxx>
 #include <couchbase/io/dns_client.hxx>
 #include <couchbase/io/http_command.hxx>
@@ -48,6 +49,14 @@ class cluster : public std::enable_shared_from_this<cluster>
         return std::shared_ptr<cluster>(new cluster(ctx));
     }
 
+    [[nodiscard]] std::pair<std::error_code, couchbase::origin> origin() const
+    {
+        if (stopped_) {
+            return { error::network_errc::cluster_closed, {} };
+        }
+        return { {}, origin_ };
+    }
+
     template<typename Handler>
     void open(const couchbase::origin& origin, Handler&& handler)
     {
@@ -128,7 +137,7 @@ class cluster : public std::enable_shared_from_this<cluster>
             if (ec) {
                 std::scoped_lock lock(self->buckets_mutex_);
                 self->buckets_.erase(bucket_name);
-            } else if (!self->session_->supports_gcccp()) {
+            } else if (self->session_ && !self->session_->supports_gcccp()) {
                 self->session_manager_->set_configuration(config, self->origin_.options());
             }
             handler(ec);
@@ -286,6 +295,36 @@ class cluster : public std::enable_shared_from_this<cluster>
     template<typename Handler>
     void do_open(Handler&& handler)
     {
+        // Warn users if they attempt to use Capella without TLS being enabled.
+        {
+            bool has_capella_host = false;
+            bool has_non_capella_host = false;
+            static std::string suffix = "cloud.couchbase.com";
+            for (const auto& node : origin_.get_hostnames()) {
+                if (auto pos = node.find(suffix); pos != std::string::npos && pos + suffix.size() == node.size()) {
+                    has_capella_host = true;
+                } else {
+                    has_non_capella_host = true;
+                }
+            }
+
+            if (has_capella_host && !origin_.options().enable_tls) {
+                LOG_WARNING("[{}]: TLS is required when connecting to Couchbase Capella. Please enable TLS by prefixing "
+                            "the connection string with \"couchbases://\" (note the final 's').",
+                            id_);
+            }
+
+            if (origin_.options().enable_tls                   /* TLS is enabled */
+                && origin_.options().trust_certificate.empty() /* No CA certificate (or other SDK-specific trust source) is specified */
+                && origin_.options().tls_verify != tls_verify_mode::none /* The user did not disable all TLS verification */
+                && has_non_capella_host /* The connection string has a hostname that does NOT end in ".cloud.couchbase.com" */) {
+                LOG_ERROR("[{}] When TLS is enabled, the cluster options must specify certificate(s) to trust. (Unless connecting to "
+                          "cloud.couchbase.com.)",
+                          id_);
+                return handler(error::common_errc::invalid_argument);
+            }
+        }
+
         if (origin_.options().enable_tls) {
             tls_.set_options(asio::ssl::context::default_workarounds | asio::ssl::context::no_sslv2 | asio::ssl::context::no_sslv3);
             switch (origin_.options().tls_verify) {
@@ -305,6 +344,16 @@ class cluster : public std::enable_shared_from_this<cluster>
                     LOG_ERROR("[{}]: unable to load verify file \"{}\": {}", id_, origin_.options().trust_certificate, ec.message());
                     return handler(ec);
                 }
+            } else {
+                // add the cappela Root CA if no other CA was specified.
+                std::error_code ec{};
+                LOG_DEBUG(R"([{}]: use default CA for TLS verify)", id_);
+                tls_.add_certificate_authority(
+                  asio::const_buffer(couchbase::default_ca::capellaCaCert, strlen(couchbase::default_ca::capellaCaCert)), ec);
+                if (ec) {
+                    LOG_WARNING("[{}]: unable to load default CAs: {}", id_, ec.message());
+                    // we don't consider this fatal and try to continue without it
+                }
             }
 #ifdef COUCHBASE_CXX_CLIENT_TLS_KEY_LOG_FILE
             SSL_CTX_set_keylog_callback(tls_.native_handle(), [](const SSL* /* ssl */, const char* line) {

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

@@ -17,6 +17,7 @@
 
 #pragma once
 
+#include <couchbase/io/ip_protocol.hxx>
 #include <couchbase/metrics/logging_meter_options.hxx>
 #include <couchbase/service_type.hxx>
 #include <couchbase/timeout_defaults.hxx>
@@ -34,6 +35,7 @@ enum class tls_verify_mode {
 
 struct cluster_options {
     std::chrono::milliseconds bootstrap_timeout = timeout_defaults::bootstrap_timeout;
+    std::chrono::milliseconds resolve_timeout = timeout_defaults::resolve_timeout;
     std::chrono::milliseconds connect_timeout = timeout_defaults::connect_timeout;
     std::chrono::milliseconds key_value_timeout = timeout_defaults::key_value_timeout;
     std::chrono::milliseconds key_value_durable_timeout = timeout_defaults::key_value_durable_timeout;
@@ -48,7 +50,7 @@ struct cluster_options {
     std::string trust_certificate{};
     bool enable_mutation_tokens{ true };
     bool enable_tcp_keep_alive{ true };
-    bool force_ipv4{ false };
+    io::ip_protocol use_ip_protocol{ io::ip_protocol::any };
     bool enable_dns_srv{ true };
     bool show_queries{ false };
     bool enable_unordered_execution{ true };

package/deps/couchbase-transactions-cxx/deps/couchbase-cxx-client/couchbase/crypto/cbcrypto.cc

@@ -50,7 +50,7 @@ hash(std::string_view key, std::string_view data, LPCWSTR algorithm, int flags)
     DWORD cbHashObject = 0;
 
     // calculate the size of the buffer to hold the hash object
-    status = BCryptGetProperty(hAlg, BCRYPT_OBJECT_LENGTH, (PBYTE)&cbHashObject, sizeof(DWORD), &pcbResult, 0);
+    status = BCryptGetProperty(hAlg, BCRYPT_OBJECT_LENGTH, reinterpret_cast<PBYTE>(&cbHashObject), sizeof(DWORD), &pcbResult, 0);
     if (status < 0) {
         BCryptCloseAlgorithmProvider(hAlg, 0);
         throw std::runtime_error("digest: BCryptGetProperty return: " + std::to_string(status));
@@ -58,14 +58,14 @@ hash(std::string_view key, std::string_view data, LPCWSTR algorithm, int flags)
 
     // calculate the length of the hash
     DWORD cbHash = 0;
-    status = BCryptGetProperty(hAlg, BCRYPT_HASH_LENGTH, (PBYTE)&cbHash, sizeof(DWORD), &pcbResult, 0);
+    status = BCryptGetProperty(hAlg, BCRYPT_HASH_LENGTH, reinterpret_cast<PBYTE>(&cbHash), sizeof(DWORD), &pcbResult, 0);
     if (status < 0) {
         BCryptCloseAlgorithmProvider(hAlg, 0);
         throw std::runtime_error("digest: BCryptGetProperty return: " + std::to_string(status));
     }
 
     // allocate the hash object on the heap
-    uniqueHeapPtr pbHashObject((PBYTE)HeapAlloc(GetProcessHeap(), 0, cbHashObject));
+    uniqueHeapPtr pbHashObject(static_cast<PBYTE>(HeapAlloc(GetProcessHeap(), 0, cbHashObject)));
     if (!pbHashObject) {
         BCryptCloseAlgorithmProvider(hAlg, 0);
         throw std::bad_alloc();
@@ -76,13 +76,13 @@ hash(std::string_view key, std::string_view data, LPCWSTR algorithm, int flags)
 
     // create the hash
     BCRYPT_HASH_HANDLE hHash;
-    status = BCryptCreateHash(hAlg, &hHash, pbHashObject.get(), cbHashObject, (PUCHAR)key.data(), ULONG(key.size()), 0);
+    status = BCryptCreateHash(hAlg, &hHash, pbHashObject.get(), cbHashObject, (PUCHAR)key.data(), static_cast<ULONG>(key.size()), 0);
     if (status < 0) {
         BCryptCloseAlgorithmProvider(hAlg, 0);
         throw std::runtime_error("digest: BCryptCreateHash return: " + std::to_string(status));
     }
 
-    status = BCryptHashData(hHash, (PBYTE)data.data(), ULONG(data.size()), 0);
+    status = BCryptHashData(hHash, (PBYTE)data.data(), static_cast<ULONG>(data.size()), 0);
     if (status < 0) {
         BCryptCloseAlgorithmProvider(hAlg, 0);
         BCryptDestroyHash(hHash);

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

@@ -0,0 +1,26 @@
+/* -*- Mode: C++; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */
+/*
+ *   Copyright 2020-2021 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
+
+namespace couchbase
+{
+enum class design_document_namespace {
+    development = 0,
+    production,
+};
+} // namespace couchbase

package/deps/{couchbase-cxx-client/couchbase/operations/management/design_document_fmt.hxx → couchbase-transactions-cxx/deps/couchbase-cxx-client/couchbase/design_document_namespace_fmt.hxx}

@@ -17,12 +17,12 @@
 
 #pragma once
 
-#include <couchbase/operations/management/design_document.hxx>
+#include <couchbase/design_document_namespace.hxx>
 
 #include <fmt/core.h>
 
 template<>
-struct fmt::formatter<couchbase::operations::design_document::name_space> {
+struct fmt::formatter<couchbase::design_document_namespace> {
     template<typename ParseContext>
     constexpr auto parse(ParseContext& ctx)
     {
@@ -30,15 +30,15 @@ struct fmt::formatter<couchbase::operations::design_document::name_space> {
     }
 
     template<typename FormatContext>
-    auto format(couchbase::operations::design_document::name_space ns, FormatContext& ctx) const
+    auto format(couchbase::design_document_namespace ns, FormatContext& ctx) const
     {
         string_view name = "unknown";
         switch (ns) {
-            case couchbase::operations::design_document::name_space::development:
+            case couchbase::design_document_namespace::development:
                 name = "development";
                 break;
 
-            case couchbase::operations::design_document::name_space::production:
+            case couchbase::design_document_namespace::production:
                 name = "production";
                 break;
         }

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

@@ -19,6 +19,7 @@
 
 #include <couchbase/service_type.hxx>
 
+#include <array>
 #include <chrono>
 #include <map>
 #include <optional>

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

@@ -17,6 +17,9 @@
 
 #include <couchbase/document_id.hxx>
 
+#include <couchbase/utils/binary.hxx>
+#include <couchbase/utils/unsigned_leb128.hxx>
+
 #include <fmt/core.h>
 
 #include <algorithm>
@@ -25,9 +28,9 @@
 namespace couchbase
 {
 document_id::document_id()
-  : scope_("_default")
-  , collection_("_default")
-  , collection_path_("_default._default")
+  : scope_{ "_default" }
+  , collection_{ "_default" }
+  , collection_path_{ "_default._default" }
 {
 }
 
@@ -86,4 +89,18 @@ document_id::has_default_collection() const
 {
     return !use_collections_ || collection_path_ == "_default._default";
 }
+
+std::vector<std::byte>
+make_protocol_key(const document_id& id)
+{
+    std::vector<std::byte> key{};
+    if (id.is_collection_resolved()) {
+        utils::unsigned_leb128<std::uint32_t> encoded(id.collection_uid());
+        key.reserve(encoded.size());
+        key.insert(key.end(), encoded.begin(), encoded.end());
+    }
+    key.reserve(key.size() + id.key().size());
+    couchbase::utils::to_binary(id.key(), std::back_insert_iterator(key));
+    return key;
+}
 } // namespace couchbase

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

@@ -20,6 +20,7 @@
 #include <cstdint>
 #include <optional>
 #include <string>
+#include <vector>
 
 namespace couchbase
 {
@@ -99,4 +100,8 @@ struct document_id {
     bool use_collections_{ true };
     bool use_any_session_{ false };
 };
+
+[[nodiscard]] std::vector<std::byte>
+make_protocol_key(const document_id& id);
+
 } // namespace couchbase

package/deps/couchbase-transactions-cxx/deps/couchbase-cxx-client/couchbase/error_context/analytics.hxx

@@ -39,6 +39,8 @@ struct analytics {
     std::string path{};
     std::uint32_t http_status{};
     std::string http_body{};
+    std::string hostname{};
+    std::uint16_t port{};
 
     std::optional<std::string> last_dispatched_to{};
     std::optional<std::string> last_dispatched_from{};

package/deps/couchbase-transactions-cxx/deps/couchbase-cxx-client/couchbase/error_context/http.hxx

@@ -35,6 +35,8 @@ struct http {
     std::string path{};
     std::uint32_t http_status{};
     std::string http_body{};
+    std::string hostname{};
+    std::uint16_t port{};
 
     std::optional<std::string> last_dispatched_to{};
     std::optional<std::string> last_dispatched_from{};

package/deps/couchbase-transactions-cxx/deps/couchbase-cxx-client/couchbase/error_context/key_value.hxx

@@ -17,9 +17,9 @@
 
 #pragma once
 
+#include <couchbase/cas.hxx>
 #include <couchbase/document_id.hxx>
 #include <couchbase/io/retry_reason.hxx>
-#include <couchbase/protocol/cas.hxx>
 #include <couchbase/protocol/enhanced_error_info.hxx>
 #include <couchbase/protocol/status.hxx>
 #include <couchbase/topology/error_map.hxx>
@@ -36,7 +36,7 @@ struct key_value {
     document_id id;
     std::error_code ec{};
     std::uint32_t opaque{};
-    protocol::cas cas{};
+    couchbase::cas cas{};
     std::optional<protocol::status> status_code{};
     std::optional<error_map::error_info> error_map_info{};
     std::optional<protocol::enhanced_error_info> enhanced_error_info{};