couchbase 3.4.0 → 3.4.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 97dc31f5d538a882e27e0d837a7865798a5d50a3ba04f76592683a8300211b36
-  data.tar.gz: 9c6f2fea36ce5b5fcdaf26f93d18e5a8d1024dd9aa82024eb296b08587c14cf5
+  metadata.gz: 738d96522993c221d75dc83546dc6c9f5447309fbbe4969f6fb92719b0427e78
+  data.tar.gz: 5189c37096e7193f5756050a9713bd7d8f75acd8949e5afe2402fc1834ed538f
 SHA512:
-  metadata.gz: 1c63fafd6e367c42f670dcc93d54c1a6e1ed47af28c349e22be3d2167fe9b734530146b3e03116b222813c202bfecbc14d0f1ad2d704bf82e8deda1ef6e39d8d
-  data.tar.gz: e0593d3d352f29054ee3be5c272c24c968f03960e845ff45cb67cfaaeb61c2e59828c6e03a4271d21200f5a3a84a234b101a25880b0ff32cb076b694d4d9f05c
+  metadata.gz: 85632d1eea3c7139c246f80fadbe8135aacd4b550fdd49a0e33a98342846d39d7d1a7b45abd2d03f1ecbecb9fbdb3401d5ef16b2c52e4bfa3c08edcebfa976e3
+  data.tar.gz: 34202c48810d9ebc8c9930a1f860acafa9a97b4de8304a22e56fa811a9462f02a857d277fb3abf1572226244ed05aeaafd61d23689a74aad6cdae83c33669fca

data/README.md

@@ -23,7 +23,7 @@ The library has been tested with MRI 3.0, 3.1 and 3.2. Supported platforms are L
 Add this line to your application's Gemfile:
 
 ```ruby
-gem "couchbase", "3.4.0"
+gem "couchbase", "3.4.1"
 ```
 
 And then execute:

data/ext/couchbase/CMakeLists.txt

@@ -296,8 +296,6 @@ set(couchbase_cxx_client_FILES
         core/impl/retry_reason.cxx
         core/impl/search_error_category.cxx
         core/impl/streaming_json_lexter_error_category.cxx
-        core/impl/unlock.cxx
-        core/impl/watch_query_indexes.cxx
         core/impl/subdoc/array_add_unique.cxx
         core/impl/subdoc/array_append.cxx
         core/impl/subdoc/array_insert.cxx
@@ -317,9 +315,12 @@ set(couchbase_cxx_client_FILES
         core/impl/subdoc/upsert.cxx
         core/impl/touch.cxx
         core/impl/transaction_error_category.cxx
+        core/impl/transaction_get_result.cxx
         core/impl/transaction_op_error_category.cxx
+        core/impl/unlock.cxx
         core/impl/upsert.cxx
         core/impl/view_error_category.cxx
+        core/impl/watch_query_indexes.cxx
         core/io/dns_config.cxx
         core/io/http_parser.cxx
         core/io/mcbp_message.cxx
@@ -398,7 +399,11 @@ if (WIN32)
 endif ()
 
 if (NOT COUCHBASE_CXX_CLIENT_POST_LINKED_OPENSSL)
-    target_link_libraries(couchbase_cxx_client PUBLIC OpenSSL::SSL OpenSSL::Crypto)
+    if (TARGET PkgConfig::PKG_CONFIG_OPENSSL)
+        target_link_libraries(couchbase_cxx_client PUBLIC PkgConfig::PKG_CONFIG_OPENSSL)
+    else()
+        target_link_libraries(couchbase_cxx_client PUBLIC OpenSSL::SSL OpenSSL::Crypto)
+    endif()
 endif ()
 
 option(COUCHBASE_CXX_CLIENT_BUILD_TESTS "Build test programs" TRUE)

data/ext/couchbase/cmake/CompilerWarnings.cmake

@@ -67,8 +67,8 @@ function(set_project_warnings project_name)
       -Wuseless-cast # warn if you perform a cast to the same type
       -Wdeprecated-declarations # warn if [[deprecated]] elements being used
   )
-  set(CLANG_WARNINGS ${COMMON_WARNINGS}
-      -Wshadow # warn the user if a variable declaration shadows one from a parent context
+  set(CLANG_WARNINGS ${COMMON_WARNINGS} -Wshadow # warn the user if a variable declaration shadows one from a parent
+                                                 # context
   )
 
   if(MSVC)
@@ -76,9 +76,17 @@ function(set_project_warnings project_name)
   elseif(CMAKE_CXX_COMPILER_ID MATCHES ".*Clang")
     set(PROJECT_WARNINGS ${CLANG_WARNINGS})
   elseif(CMAKE_CXX_COMPILER_ID STREQUAL "GNU")
-    if (CMAKE_CXX_COMPILER_VERSION VERSION_GREATER_EQUAL "12.0.0" AND NOT CMAKE_BUILD_TYPE STREQUAL "Debug")
+    if(CMAKE_CXX_COMPILER_VERSION VERSION_GREATER_EQUAL "11.0.0"
+       AND NOT
+           CMAKE_BUILD_TYPE
+           STREQUAL
+           "Debug")
       # One of the occurrences: https://github.com/chriskohlhoff/asio/pull/1176
-      set(GCC_WARNINGS ${GCC_WARNINGS} -Wno-error=null-dereference -Wno-error=array-bounds)
+      set(GCC_WARNINGS
+          ${GCC_WARNINGS}
+          -Wno-error=null-dereference
+          -Wno-error=array-bounds
+          -Wno-error=stringop-overflow)
     endif()
     set(PROJECT_WARNINGS ${GCC_WARNINGS})
   else()

data/ext/couchbase/cmake/Documentation.cmake

@@ -11,11 +11,12 @@ if(DOXYGEN_FOUND AND DOT)
   file(
     GLOB_RECURSE
     COUCHBASE_CXX_CLIENT_PUBLIC_HEADERS
-    ${PROJECT_SOURCE_DIR}/couchbase/*.hxx
-    ${PROJECT_SOURCE_DIR}/docs/*.hxx)
+    ${PROJECT_SOURCE_DIR}/couchbase/**/*.hxx
+    ${PROJECT_SOURCE_DIR}/docs/*.hxx
+    ${PROJECT_SOURCE_DIR}/docs/*.md)
 
   set(DOXYGEN_INPUT_DIR ${PROJECT_SOURCE_DIR}/couchbase)
-  set(DOXYGEN_OUTPUT_DIR ${PROJECT_BINARY_DIR}/couchbase-cxx-client-${couchbase_cxx_client_VERSION})
+  set(DOXYGEN_OUTPUT_DIR ${PROJECT_BINARY_DIR}/couchbase-cxx-client-${COUCHBASE_CXX_CLIENT_SEMVER})
   set(DOXYGEN_INDEX_FILE ${DOXYGEN_OUTPUT_DIR}/html/index.html)
   set(DOXYGEN_CONFIG_TEMPLATE ${PROJECT_SOURCE_DIR}/docs/Doxyfile.in)
   set(DOXYGEN_CONFIG ${PROJECT_BINARY_DIR}/Doxyfile)

data/ext/couchbase/cmake/OpenSSL.cmake

@@ -14,11 +14,21 @@ else()
   if(NOT OPENSSL_ROOT_DIR)
     if(APPLE AND COUCHBASE_CXX_CLIENT_USE_HOMEBREW_TO_DETECT_OPENSSL)
       execute_process(
-        COMMAND brew --prefix openssl@1.1
+        COMMAND brew --prefix openssl
         OUTPUT_VARIABLE OPENSSL_ROOT_DIR
+        ERROR_VARIABLE HOMEBREW_STDERR
         ERROR_QUIET OUTPUT_STRIP_TRAILING_WHITESPACE)
       if(OPENSSL_ROOT_DIR)
-        message(STATUS "Found OpenSSL prefix using homebrew: ${OPENSSL_ROOT_DIR}")
+        message(STATUS "Found OpenSSL prefix using Homebrew: ${OPENSSL_ROOT_DIR}")
+      else()
+        execute_process(
+          COMMAND brew --prefix openssl@1.1
+          OUTPUT_VARIABLE OPENSSL_ROOT_DIR
+          ERROR_VARIABLE HOMEBREW_STDERR
+          ERROR_QUIET OUTPUT_STRIP_TRAILING_WHITESPACE)
+        if(OPENSSL_ROOT_DIR)
+          message(STATUS "Found OpenSSL 1.1 prefix using Homebrew: ${OPENSSL_ROOT_DIR}")
+        endif()
       endif()
     endif()
     if(MSVC AND COUCHBASE_CXX_CLIENT_USE_SCOOP_TO_DETECT_OPENSSL)
@@ -32,11 +42,46 @@ else()
       endif()
     endif()
   endif()
-  include(FindOpenSSL)
-  if(OPENSSL_LIBRARIES AND OPENSSL_INCLUDE_DIR)
-    message(STATUS "OPENSSL_VERSION: ${OPENSSL_VERSION}")
-    message(STATUS "OPENSSL_INCLUDE_DIR: ${OPENSSL_INCLUDE_DIR}")
-    message(STATUS "OPENSSL_LIBRARIES: ${OPENSSL_LIBRARIES}")
+
+  find_package(OpenSSL 1.1)
+  if(OpenSSL_FOUND)
+    try_compile(
+      OPENSSL_USABLE ${CMAKE_CURRENT_BINARY_DIR}
+      ${CMAKE_CURRENT_SOURCE_DIR}/cmake/test_openssl.cxx
+      LINK_LIBRARIES OpenSSL::SSL CXX_STANDARD 17)
+    if( OPENSSL_USABLE)
+      message(STATUS "OPENSSL_VERSION: ${OPENSSL_VERSION}")
+      message(STATUS "OPENSSL_INCLUDE_DIR: ${OPENSSL_INCLUDE_DIR}")
+      message(STATUS "OPENSSL_LIBRARIES: ${OPENSSL_LIBRARIES}")
+    else()
+      if(UNIX)
+        message(
+          STATUS
+            "Cannot use OpenSSL ${OPENSSL_VERSION} at \"${OPENSSL_INCLUDE_DIR}\" and \"${OPENSSL_LIBRARIES}\". Will try to use from pkg-config."
+        )
+        find_package(PkgConfig REQUIRED)
+        pkg_check_modules(PKG_CONFIG_OPENSSL REQUIRED IMPORTED_TARGET GLOBAL openssl11)
+        if(PKG_CONFIG_OPENSSL_FOUND)
+          message(STATUS "PKG_CONFIG_OPENSSL_VERSION: ${PKG_CONFIG_OPENSSL_VERSION}")
+          message(STATUS "PKG_CONFIG_OPENSSL_INCLUDE_DIRS: ${PKG_CONFIG_OPENSSL_INCLUDE_DIRS}")
+          message(STATUS "PKG_CONFIG_OPENSSL_LIBRARIES: ${PKG_CONFIG_OPENSSL_LIBRARIES}")
+        else()
+          message(FATAL_ERROR "Cannot Find OpenSSL using pkg-config, find_package() returns unusable setup")
+        endif()
+      else()
+        message(FATAL_ERROR "OpenSSL discovered by find_package() returns unusable setup")
+      endif()
+    endif()
+  elseif(UNIX)
+    find_package(PkgConfig REQUIRED)
+    pkg_check_modules(PKG_CONFIG_OPENSSL REQUIRED IMPORTED_TARGET GLOBAL openssl11)
+    if(PKG_CONFIG_OPENSSL_FOUND)
+      message(STATUS "PKG_CONFIG_OPENSSL_VERSION: ${PKG_CONFIG_OPENSSL_VERSION}")
+      message(STATUS "PKG_CONFIG_OPENSSL_INCLUDE_DIRS: ${PKG_CONFIG_OPENSSL_INCLUDE_DIRS}")
+      message(STATUS "PKG_CONFIG_OPENSSL_LIBRARIES: ${PKG_CONFIG_OPENSSL_LIBRARIES}")
+    else()
+      message(FATAL_ERROR "Cannot Find OpenSSL using pkg-config")
+    endif()
   else()
     message(FATAL_ERROR "Cannot build Couchbase C++ SDK without OpenSSL")
   endif()

data/ext/couchbase/cmake/VersionInfo.cmake

@@ -25,6 +25,37 @@ if(NOT COUCHBASE_CXX_CLIENT_GIT_DESCRIBE)
 endif()
 
 string(TIMESTAMP COUCHBASE_CXX_CLIENT_BUILD_TIMESTAMP "%Y-%m-%d %H:%M:%S" UTC)
+string(TIMESTAMP COUCHBASE_CXX_CLIENT_BUILD_DATE "%Y-%m-%d" UTC)
+
+# set(couchbase_cxx_client_BUILD_NUMBER 142)
+# set(COUCHBASE_CXX_CLIENT_GIT_DESCRIBE "1.0.0-beta.4-27-g6807da0") #-> "couchbase_cxx_client-1.0.0-beta.4+142.27.6807da0"
+# set(COUCHBASE_CXX_CLIENT_GIT_DESCRIBE "1.0.0-beta.4-0-g6807da0")  #-> "couchbase_cxx_client-1.0.0-beta.4"
+# set(COUCHBASE_CXX_CLIENT_GIT_DESCRIBE "1.0.0-27-g6807da0")        #-> "couchbase_cxx_client-1.0.0+142.27.6807da0"
+# set(COUCHBASE_CXX_CLIENT_GIT_DESCRIBE "1.0.0-0-g6807da0")         #-> "couchbase_cxx_client-1.0.0"
+# set(COUCHBASE_CXX_CLIENT_GIT_DESCRIBE "1.0.0")                    #-> "couchbase_cxx_client-1.0.0"
+set(COUCHBASE_CXX_CLIENT_SEMVER "${couchbase_cxx_client_VERSION}")
+set(COUCHBASE_CXX_CLIENT_PACKAGE_VERSION "${couchbase_cxx_client_VERSION}")
+set(COUCHBASE_CXX_CLIENT_PACKAGE_RELEASE "${couchbase_cxx_client_BUILD_NUMBER}")
+if(COUCHBASE_CXX_CLIENT_GIT_DESCRIBE MATCHES
+   "^([0-9]+\\.[0-9]+\\.[0-9]+)(-([a-zA-Z0-9\\.]+))?(-([0-9]+)-g([a-zA-Z0-9]+))?$")
+  set(COUCHBASE_CXX_CLIENT_SEMVER "${CMAKE_MATCH_1}")
+  set(COUCHBASE_CXX_CLIENT_PACKAGE_VERSION "${CMAKE_MATCH_1}")
+  if(CMAKE_MATCH_3) # pre-release
+    set(COUCHBASE_CXX_CLIENT_SEMVER "${COUCHBASE_CXX_CLIENT_SEMVER}-${CMAKE_MATCH_3}")
+    set(COUCHBASE_CXX_CLIENT_PACKAGE_RELEASE "${CMAKE_MATCH_3}.${couchbase_cxx_client_BUILD_NUMBER}")
+  endif()
+  if(CMAKE_MATCH_5 AND CMAKE_MATCH_5 GREATER 0) # number_of_commits.build_number.sha1
+    set(COUCHBASE_CXX_CLIENT_SEMVER
+        "${COUCHBASE_CXX_CLIENT_SEMVER}+${CMAKE_MATCH_5}.${couchbase_cxx_client_BUILD_NUMBER}.${CMAKE_MATCH_6}")
+    if(CMAKE_MATCH_3) # pre-release
+      set(COUCHBASE_CXX_CLIENT_PACKAGE_RELEASE
+          "${CMAKE_MATCH_3}.${CMAKE_MATCH_5}.${couchbase_cxx_client_BUILD_NUMBER}.${CMAKE_MATCH_6}")
+    else()
+      set(COUCHBASE_CXX_CLIENT_PACKAGE_RELEASE "${CMAKE_MATCH_5}.${couchbase_cxx_client_BUILD_NUMBER}.${CMAKE_MATCH_6}")
+    endif()
+  endif()
+endif()
+
 configure_file(${PROJECT_SOURCE_DIR}/cmake/build_version.hxx.in
                ${PROJECT_BINARY_DIR}/generated/couchbase/build_version.hxx @ONLY)
 configure_file(${PROJECT_SOURCE_DIR}/cmake/build_config.hxx.in
@@ -47,9 +78,14 @@ file(
 #define COUCHBASE_CXX_CLIENT_LINK_OPTIONS \"$<TARGET_PROPERTY:couchbase_cxx_client,LINK_OPTIONS>\"
 #define COUCHBASE_CXX_CLIENT_POST_LINKED_OPENSSL \"${COUCHBASE_CXX_CLIENT_POST_LINKED_OPENSSL}\"
 
-#define OPENSSL_CRYPTO_LIBRARIES \"${OPENSSL_CRYPTO_LIBRARIES}\"
-#define OPENSSL_SSL_LIBRARIES \"${OPENSSL_SSL_LIBRARIES}\"
-#define OPENSSL_INCLUDE_DIR \"${OPENSSL_INCLUDE_DIR}\"
+#define OPENSSL_SSL_IMPORTED_LOCATION \"$<$<TARGET_EXISTS:OpenSSL::SSL>:$<TARGET_PROPERTY:OpenSSL::SSL,IMPORTED_LOCATION>>\"
+#define OPENSSL_SSL_INTERFACE_INCLUDE_DIRECTORIES \"$<$<TARGET_EXISTS:OpenSSL::SSL>:$<TARGET_PROPERTY:OpenSSL::SSL,INTERFACE_INCLUDE_DIRECTORIES>>\"
+#define OPENSSL_SSL_INTERFACE_LINK_LIBRARIES \"$<$<TARGET_EXISTS:OpenSSL::SSL>:$<TARGET_PROPERTY:OpenSSL::SSL,INTERFACE_LINK_LIBRARIES>>\"
+#define OPENSSL_CRYPTO_IMPORTED_LOCATION \"$<$<TARGET_EXISTS:OpenSSL::Crypto>:$<TARGET_PROPERTY:OpenSSL::Crypto,IMPORTED_LOCATION>>\"
+#define OPENSSL_CRYPTO_INTERFACE_INCLUDE_DIRECTORIES \"$<$<TARGET_EXISTS:OpenSSL::Crypto>:$<TARGET_PROPERTY:OpenSSL::Crypto,INTERFACE_INCLUDE_DIRECTORIES>>\"
+#define OPENSSL_CRYPTO_INTERFACE_LINK_LIBRARIES \"$<$<TARGET_EXISTS:OpenSSL::Crypto>:$<TARGET_PROPERTY:OpenSSL::Crypto,INTERFACE_LINK_LIBRARIES>>\"
+#define OPENSSL_PKG_CONFIG_INTERFACE_INCLUDE_DIRECTORIES \"$<$<TARGET_EXISTS:PkgConfig::PKG_CONFIG_OPENSSL>:$<TARGET_PROPERTY:PkgConfig::PKG_CONFIG_OPENSSL,INTERFACE_INCLUDE_DIRECTORIES>>\"
+#define OPENSSL_PKG_CONFIG_INTERFACE_LINK_LIBRARIES \"$<$<TARGET_EXISTS:PkgConfig::PKG_CONFIG_OPENSSL>:$<TARGET_PROPERTY:PkgConfig::PKG_CONFIG_OPENSSL,INTERFACE_LINK_LIBRARIES>>\"
 
 #define CMAKE_BUILD_TYPE \"${CMAKE_BUILD_TYPE}\"
 #define CMAKE_VERSION \"${CMAKE_VERSION}\"

data/ext/couchbase/cmake/test_openssl.cxx

@@ -0,0 +1,7 @@
+#include <openssl/crypto.h>
+
+int
+main()
+{
+    return static_cast<int>(OpenSSL_version_num());
+}

data/ext/couchbase/core/crypto/CMakeLists.txt

@@ -4,7 +4,11 @@ target_link_libraries(couchbase_crypto PRIVATE project_options project_warnings)
 target_include_directories(couchbase_crypto PRIVATE ../..)
 
 if(NOT COUCHBASE_CXX_CLIENT_POST_LINKED_OPENSSL)
-  target_link_libraries(couchbase_crypto PUBLIC OpenSSL::SSL OpenSSL::Crypto)
+  if (TARGET PkgConfig::PKG_CONFIG_OPENSSL)
+    target_link_libraries(couchbase_crypto PUBLIC PkgConfig::PKG_CONFIG_OPENSSL)
+  else()
+    target_link_libraries(couchbase_crypto PUBLIC OpenSSL::SSL OpenSSL::Crypto)
+  endif()
 endif()
 
 if(WIN32)

data/ext/couchbase/core/impl/collection_query_index_manager.cxx

@@ -22,14 +22,14 @@ namespace couchbase
 {
 
 void
-collection_query_index_manager::get_all_indexes(const get_all_query_indexes_options& options, get_all_indexes_handler&& handler) const
+collection_query_index_manager::get_all_indexes(const get_all_query_indexes_options& options, get_all_query_indexes_handler&& handler) const
 {
     return core::impl::initiate_get_all_query_indexes(core_,
                                                       "",
                                                       options.build(),
                                                       core::query_context(bucket_name_, scope_name_),
                                                       collection_name_,
-                                                      std::forward<get_all_indexes_handler>(handler));
+                                                      std::forward<get_all_query_indexes_handler>(handler));
 }
 
 void
@@ -90,4 +90,4 @@ collection_query_index_manager::watch_indexes(std::vector<std::string> index_nam
     return core::impl::initiate_watch_query_indexes(
       core_, "", std::move(index_names), options.build(), { bucket_name_, scope_name_ }, collection_name_, std::move(handler));
 }
-} // namespace couchbase
+} // namespace couchbase

data/ext/couchbase/core/impl/get_all_query_indexes.cxx

@@ -45,7 +45,7 @@ initiate_get_all_query_indexes(std::shared_ptr<couchbase::core::cluster> core,
                                couchbase::get_all_query_indexes_options::built options,
                                query_context query_ctx,
                                std::string collection_name,
-                               get_all_indexes_handler&& handler)
+                               get_all_query_indexes_handler&& handler)
 {
     core->execute(
       operations::management::query_index_get_all_request{
@@ -68,9 +68,9 @@ void
 initiate_get_all_query_indexes(std::shared_ptr<couchbase::core::cluster> core,
                                std::string bucket_name,
                                couchbase::get_all_query_indexes_options::built options,
-                               get_all_indexes_handler&& handler)
+                               get_all_query_indexes_handler&& handler)
 {
     initiate_get_all_query_indexes(core, std::move(bucket_name), options, {}, "", std::move(handler));
 }
 
-} // namespace couchbase::core::impl
+} // namespace couchbase::core::impl

data/ext/couchbase/core/impl/transaction_get_result.cxx

@@ -0,0 +1,54 @@
+
+
+#include <core/transactions/transaction_get_result.hxx>
+#include <couchbase/transactions/transaction_get_result.hxx>
+
+namespace couchbase::transactions
+{
+
+transaction_get_result::transaction_get_result()
+  : base_(std::make_shared<couchbase::core::transactions::transaction_get_result>())
+{
+}
+
+const std::vector<std::byte>&
+transaction_get_result::content() const
+{
+    return base_->content();
+}
+void
+transaction_get_result::content(std::vector<std::byte> content)
+{
+    return base_->content(content);
+}
+void
+transaction_get_result::content(std::vector<std::byte>&& content)
+{
+    return base_->content(content);
+}
+const std::string
+transaction_get_result::key() const
+{
+    return base_->key();
+}
+const std::string
+transaction_get_result::bucket() const
+{
+    return base_->bucket();
+}
+const std::string
+transaction_get_result::scope() const
+{
+    return base_->scope();
+}
+const std::string
+transaction_get_result::collection() const
+{
+    return base_->collection();
+}
+const couchbase::cas
+transaction_get_result::cas() const
+{
+    return base_->cas();
+}
+} // namespace couchbase::transactions

data/ext/couchbase/core/meta/CMakeLists.txt

@@ -7,11 +7,13 @@ target_link_libraries(
           snappy
           fmt::fmt
           spdlog::spdlog)
-target_include_directories(couchbase_meta PRIVATE
-        ${PROJECT_BINARY_DIR}/generated
-        ${PROJECT_SOURCE_DIR}
-        ${PROJECT_SOURCE_DIR}/third_party/http_parser)
+target_include_directories(couchbase_meta PRIVATE ${PROJECT_BINARY_DIR}/generated ${PROJECT_SOURCE_DIR}
+                                                  ${PROJECT_SOURCE_DIR}/third_party/http_parser)
 
 if(NOT COUCHBASE_CXX_CLIENT_POST_LINKED_OPENSSL)
-  target_link_libraries(couchbase_meta PUBLIC OpenSSL::SSL OpenSSL::Crypto)
+  if (TARGET PkgConfig::PKG_CONFIG_OPENSSL)
+    target_link_libraries(couchbase_meta PUBLIC PkgConfig::PKG_CONFIG_OPENSSL)
+  else()
+    target_link_libraries(couchbase_meta PUBLIC OpenSSL::SSL OpenSSL::Crypto)
+  endif()
 endif()

data/ext/couchbase/core/meta/version.cxx

@@ -100,9 +100,28 @@ sdk_build_info()
     info["openssl_runtime"] = OpenSSL_version(OPENSSL_VERSION);
 #elif defined(SSLEAY_VERSION)
     info["openssl_runtime"] = SSLeay_version(SSLEAY_VERSION);
+#endif
+#if defined(OPENSSL_INFO_CONFIG_DIR)
+    info["openssl_config_dir"] = OPENSSL_info(OPENSSL_INFO_CONFIG_DIR);
+#elif defined(OPENSSL_DIR)
+    if (std::string config_dir(OpenSSL_version(OPENSSL_DIR)); !config_dir.empty()) {
+        if (auto quote = config_dir.find('"'); quote != std::string::npos && quote + 2 < config_dir.size()) {
+            info["openssl_config_dir"] = config_dir.substr(quote + 1, config_dir.size() - quote - 2);
+        } else {
+            info["openssl_config_dir"] = config_dir;
+        }
+    }
 #endif
     info["openssl_default_cert_dir"] = X509_get_default_cert_dir();
     info["openssl_default_cert_file"] = X509_get_default_cert_file();
+    info["openssl_ssl_interface_include_directories"] = OPENSSL_SSL_INTERFACE_INCLUDE_DIRECTORIES;
+    info["openssl_ssl_interface_link_libraries"] = OPENSSL_SSL_INTERFACE_LINK_LIBRARIES;
+    info["openssl_ssl_imported_location"] = OPENSSL_SSL_IMPORTED_LOCATION;
+    info["openssl_crypto_interface_imported_location"] = OPENSSL_CRYPTO_IMPORTED_LOCATION;
+    info["openssl_crypto_interface_include_directories"] = OPENSSL_CRYPTO_INTERFACE_INCLUDE_DIRECTORIES;
+    info["openssl_crypto_interface_link_libraries"] = OPENSSL_CRYPTO_INTERFACE_LINK_LIBRARIES;
+    info["openssl_pkg_config_interface_include_directories"] = OPENSSL_PKG_CONFIG_INTERFACE_INCLUDE_DIRECTORIES;
+    info["openssl_pkg_config_interface_link_libraries"] = OPENSSL_PKG_CONFIG_INTERFACE_LINK_LIBRARIES;
     info["__cplusplus"] = fmt::format("{}", __cplusplus);
 #if defined(_MSC_VER)
     info["_MSC_VER"] = fmt::format("{}", _MSC_VER);

data/ext/couchbase/core/operations/document_search.cxx

@@ -92,11 +92,14 @@ search_request::encode_to(search_request::encoded_request_type& encoded, http_co
             { "vectors", { { index_name, scan_vectors } } },
         };
     }
-    if (scope_name) {
-        body["scope"] = scope_name.value();
+    if (!collections.empty()) {
         body["collections"] = collections;
     }
 
+    for (const auto& [key, value] : raw) {
+        body[key] = utils::json::parse(value);
+    }
+
     encoded.type = type;
     encoded.headers["content-type"] = "application/json";
     encoded.method = "POST";

data/ext/couchbase/core/operations/document_search.hxx

@@ -130,7 +130,6 @@ struct search_request {
     std::optional<couchbase::core::search_highlight_style> highlight_style{};
     std::vector<std::string> highlight_fields{};
     std::vector<std::string> fields{};
-    std::optional<std::string> scope_name{};
     std::vector<std::string> collections{};
 
     std::optional<couchbase::core::search_scan_consistency> scan_consistency{};

data/ext/couchbase/core/transactions/atr_cleanup_entry.cxx

@@ -174,6 +174,7 @@ atr_cleanup_entry::do_per_doc(std::vector<doc_record> docs,
                   lookup_in_specs::get(ATR_ID).xattr(),
                   lookup_in_specs::get(TRANSACTION_ID).xattr(),
                   lookup_in_specs::get(ATTEMPT_ID).xattr(),
+                  lookup_in_specs::get(OPERATION_ID).xattr(),
                   lookup_in_specs::get(STAGED_DATA).xattr(),
                   lookup_in_specs::get(ATR_BUCKET_NAME).xattr(),
                   lookup_in_specs::get(ATR_SCOPE_NAME).xattr(),