couchbase 3.8.2 → 3.9.0

data/ext/couchbase/couchbase/transactions/transaction_get_result.hxx

@@ -18,7 +18,7 @@
 #include <string>
 
 #include <couchbase/cas.hxx>
-#include <couchbase/codec/default_json_transcoder.hxx>
+#include <couchbase/codec/lenient_json_transcoder.hxx>
 #include <couchbase/collection.hxx>
 #include <couchbase/result.hxx>
 
@@ -64,10 +64,24 @@ public:
   /**
    * Content of the document.
    *
+   * When no transcoder is given, the document is decoded leniently, without validating its
+   * common flags. Pass a transcoder explicitly to enforce its flag handling instead.
+   *
+   * @return content of the document.
+   */
+  template<typename Document, std::enable_if_t<!codec::is_transcoder_v<Document>, bool> = true>
+  [[nodiscard]] auto content_as() const -> Document
+  {
+    return codec::default_lenient_json_transcoder::decode<Document>(content());
+  }
+
+  /**
+   * Content of the document, decoded with the given transcoder.
+   *
    * @return content of the document.
    */
   template<typename Document,
-           typename Transcoder = codec::default_json_transcoder,
+           typename Transcoder,
            std::enable_if_t<!codec::is_transcoder_v<Document>, bool> = true,
            std::enable_if_t<codec::is_transcoder_v<Transcoder>, bool> = true>
   [[nodiscard]] auto content_as() const -> Document
@@ -76,7 +90,7 @@ public:
   }
 
   /**
-   * Content of the document.
+   * Content of the document, decoded with the given transcoder.
    *
    * @return content of the document.
    */

data/ext/couchbase/couchbase/transactions/transactions_config.hxx

@@ -48,10 +48,12 @@ public:
 
   transactions_config(const transactions_config& c);
 
-  transactions_config(transactions_config&& c) noexcept;
-
   auto operator=(const transactions_config& c) -> transactions_config&;
 
+  // No move operations are declared: they fall back to the copy operations, which is sufficient for
+  // this configuration object (copied once during transaction setup) and keeps a moved-from source
+  // valid -- the hook accessors dereference their pointers, so a nulled-out source would be unsafe.
+
   /**
    * @brief Get the default durability level for all transaction operations
    *

data/ext/couchbase/couchbase/transactions.hxx

@@ -24,6 +24,21 @@
 
 #include <functional>
 
+#ifndef COUCHBASE_CXX_CLIENT_DOXYGEN
+namespace couchbase
+{
+namespace transactions
+{
+class transactions_impl;
+} // namespace transactions
+
+namespace core::transactions
+{
+class transactions;
+} // namespace core::transactions
+} // namespace couchbase
+#endif
+
 namespace couchbase::transactions
 {
 using txn_logic = std::function<error(std::shared_ptr<attempt_context>)>;
@@ -32,14 +47,10 @@ using async_txn_complete_logic = std::function<void(error, transaction_result)>;
 
 /**
  * The transactions object is used to initiate a transaction.
- *
- *
  */
 class transactions
 {
 public:
-  virtual ~transactions() = default;
-
   /**
    * Run a blocking transaction.
    *
@@ -56,13 +67,8 @@ public:
    * @return an {@link error}, and a {@link transaction_result} representing the results of the
    * transaction.
    */
-  virtual auto run(txn_logic&& logic,
-                   const transaction_options& cfg) -> std::pair<error, transaction_result> = 0;
-
-  auto run(txn_logic&& logic) -> std::pair<error, transaction_result>
-  {
-    return run(std::move(logic), {});
-  }
+  auto run(txn_logic&& logic, const transaction_options& cfg = {})
+    -> std::pair<error, transaction_result>;
 
   /**
    * Run an asynchronous transaction.
@@ -83,13 +89,16 @@ public:
    * @param cfg if passed in, these options override the defaults, or those set in the {@link
    * cluster_options}.
    */
-  virtual void run(async_txn_logic&& logic,
-                   async_txn_complete_logic&& complete_callback,
-                   const transaction_options& cfg) = 0;
+  void run(async_txn_logic&& logic,
+           async_txn_complete_logic&& complete_callback,
+           const transaction_options& cfg = {});
+
+  /**
+   * @internal
+   */
+  explicit transactions(std::shared_ptr<core::transactions::transactions> core_txns);
 
-  void run(async_txn_logic&& logic, async_txn_complete_logic&& complete_callback)
-  {
-    return run(std::move(logic), std::move(complete_callback), {});
-  }
+private:
+  std::shared_ptr<transactions_impl> impl_;
 };
 } // namespace couchbase::transactions

data/ext/couchbase/couchbase/upsert_options.hxx

@@ -72,8 +72,8 @@ struct upsert_options : public common_durability_options<upsert_options> {
    *
    * If true, and the document exists, its expiry will not be modified. Otherwise the document's
    * expiry is determined by
-   * {@link #expiry(std::chrono::seconds)} or {@link
-   * #expiry(std::chrono::system_clock::time_point)}.
+   * {@link #expiry expiry(std::chrono::seconds)} or {@link #expiry
+   * expiry(std::chrono::system_clock::time_point)}.
    *
    * Requires Couchbase Server 7.0 or later.
    *
@@ -93,7 +93,7 @@ struct upsert_options : public common_durability_options<upsert_options> {
    * Sets the expiry for the document. By default the document will never expire.
    *
    * The duration must be less than 50 years. For expiry further in the future, use
-   * {@link #expiry(std::chrono::system_clock::time_point)}.
+   * {@link #expiry expiry(std::chrono::system_clock::time_point)}.
    *
    * @param duration the duration after which the document will expire (zero duration means never
    * expire).

data/ext/couchbase/couchbase/vector_query.hxx

@@ -56,7 +56,7 @@ public:
    * @param vector_field_name the document field that contains the vector
    * @param base64_vector_query a base64-encoded sequence of little-endian IEEE 754 floats
    *
-   * @snippet{trimleft} test/test_unit_search.cxx base64-vector-query
+   * @snippet{trimleft} unit/management/search.cxx base64-vector-query
    * @since 1.0.0
    * @committed
    */

data/ext/couchbase/couchbase/wait_until_ready_options.hxx

@@ -0,0 +1,111 @@
+/* -*- Mode: C++; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */
+/*
+ *   Copyright 2026-Present 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
+
+#include <couchbase/cluster_state.hxx>
+#include <couchbase/error.hxx>
+#include <couchbase/service_type.hxx>
+
+#include <functional>
+#include <set>
+#include <utility>
+
+namespace couchbase
+{
+/**
+ * Options for @ref cluster::wait_until_ready() and @ref bucket::wait_until_ready().
+ *
+ * @since 1.4.0
+ * @committed
+ */
+struct wait_until_ready_options {
+  /**
+   * Sets the state the cluster (or bucket) has to reach before the wait completes.
+   *
+   * @note @c cluster_state::offline is not a valid target and is rejected with @c
+   * errc::common::invalid_argument.
+   *
+   * @param desired_state the target state.
+   * @return reference to this object, for use in chaining.
+   *
+   * @since 1.4.0
+   * @committed
+   */
+  auto desired_state(cluster_state desired_state) -> wait_until_ready_options&
+  {
+    desired_state_ = desired_state;
+    return *this;
+  }
+
+  /**
+   * Customizes the set of services to consider. When empty, whichever services the topology reports
+   * are considered. Over couchbase2 the set is not considered.
+   *
+   * @param service_types the services to consider.
+   * @return reference to this object, for use in chaining.
+   *
+   * @since 1.4.0
+   * @committed
+   */
+  auto service_types(std::set<service_type> service_types) -> wait_until_ready_options&
+  {
+    service_types_ = std::move(service_types);
+    return *this;
+  }
+
+  /**
+   * Immutable value object representing consistent options.
+   *
+   * @since 1.4.0
+   * @internal
+   */
+  struct built {
+    cluster_state desired_state;
+    std::set<service_type> service_types;
+  };
+
+  /**
+   * Validates the options and returns them as an immutable value.
+   *
+   * @return consistent options as an immutable value
+   *
+   * @exception std::system_error with code errc::common::invalid_argument if the options are not
+   * valid
+   *
+   * @since 1.4.0
+   * @internal
+   */
+  [[nodiscard]] auto build() const -> built
+  {
+    return { desired_state_, service_types_ };
+  }
+
+private:
+  cluster_state desired_state_{ cluster_state::online };
+  std::set<service_type> service_types_{};
+};
+
+/**
+ * The signature for the handler of the @c cluster::wait_until_ready() and @c
+ * bucket::wait_until_ready() operations.
+ *
+ * @since 1.4.0
+ * @committed
+ */
+using wait_until_ready_handler = std::function<void(error)>;
+} // namespace couchbase

data/ext/couchbase/couchbase/wildcard_query.hxx

@@ -29,7 +29,7 @@ namespace couchbase
  * characters and `?` will match `1` occurrence of any character.
  *
  * Match documents where field `reviews.content` contains words starting with `"inter"`:
- * @snippet{trimleft} test_unit_search.cxx search-wildcard
+ * @snippet{trimleft} unit/management/search.cxx search-wildcard
  *
  * @see https://docs.couchbase.com/server/current/fts/fts-supported-queries-wildcard.html server
  * documentation

data/ext/extconf.rb

@@ -30,15 +30,17 @@ when /mingw/
   # ridk install 1
   # ridk install 3
   # ridk exec pacman --sync --noconfirm \
-  #   mingw-w64-ucrt-x86_64-ninja \
-  #   mingw-w64-ucrt-x86_64-cmake \
-  #   mingw-w64-ucrt-x86_64-toolchain \
-  #   mingw-w64-ucrt-x86_64-go \
-  #   mingw-w64-ucrt-x86_64-nasm \
-  #   mingw-w64-ucrt-x86_64-ccache
+  #   ${MINGW_PACKAGE_PREFIX}-ninja \
+  #   ${MINGW_PACKAGE_PREFIX}-cmake \
+  #   ${MINGW_PACKAGE_PREFIX}-toolchain \
+  #   ${MINGW_PACKAGE_PREFIX}-go \
+  #   ${MINGW_PACKAGE_PREFIX}-nasm \
+  #   ${MINGW_PACKAGE_PREFIX}-ccache
+  # MINGW_PACKAGE_PREFIX is mingw-w64-ucrt-x86_64 or mingw-w64-clang-aarch64; nasm is needed on x64 only.
   ENV["CB_STATIC_BORINGSSL"] = "true"
   ENV["CB_STATIC_STDLIB"] = "true"
-  ENV["GOROOT"] = File.join(RubyInstaller::Runtime.msys2_installation.msys_path, "ucrt64/lib/go")
+  msys2 = RubyInstaller::Runtime.msys2_installation
+  ENV["GOROOT"] = File.join(msys2.msys_path, msys2.mingw_prefix, "lib/go") # /ucrt64 or /clangarm64
 end
 
 pp ENV.select { |k, _| k =~ /^CB_|^DEBUG$/ }.merge("SDK_VERSION" => SDK_VERSION)
@@ -108,7 +110,9 @@ end
 extconf_include = File.expand_path("cache/extconf_include.rb", __dir__)
 if File.exist?(extconf_include)
   puts "-- include extra cmake options from #{extconf_include}"
-  eval(File.read(extconf_include)) # rubocop:disable Security/Eval
+  # Evaluated with the file name so that __dir__ inside the snippet resolves to the
+  # cache directory on the installing machine rather than nil.
+  eval(File.read(extconf_include), binding, extconf_include) # rubocop:disable Security/Eval
 end
 
 if ENV["CB_STATIC"] || ENV["CB_STATIC_BORINGSSL"]
@@ -146,9 +150,10 @@ if RbConfig::CONFIG["target_os"].include?('mingw')
   require "ruby_installer/runtime"
   RubyInstaller::Runtime.enable_dll_search_paths
   RubyInstaller::Runtime.enable_msys_apps
-  cc = RbConfig::CONFIG["CC"]
-  cxx = RbConfig::CONFIG["CXX"]
+  cc = RbConfig::CONFIG["CC"].split.first
+  cxx = RbConfig::CONFIG["CXX"].split.first # RubyInstaller appends flags, e.g. "g++ -std=gnu++11"
   cmake_flags << "-G Ninja"
+  cmake_flags << "-DWARNINGS_AS_ERRORS=OFF" # core CI checks Windows warnings with MSVC only
   cmake_flags << "-DRUBY_LIBRUBY=#{File.basename(RbConfig::CONFIG['LIBRUBY_SO'], ".#{RbConfig::CONFIG['SOEXT']}")}"
 end