couchbase 3.4.2 → 3.4.3

data/ext/couchbase.cxx

@@ -270,9 +270,9 @@ init_versions(VALUE mCouchbase)
     VALUE cb_CoreInfo = rb_hash_new();
     for (const auto& [name, value] : couchbase::core::meta::sdk_build_info()) {
         if (name == "version_major" || name == "version_minor" || name == "version_patch" || name == "version_build" ||
-            name == "__cplusplus" || name == "_MSC_VER") {
+            name == "__cplusplus" || name == "_MSC_VER" || name == "mozilla_ca_bundle_size") {
             rb_hash_aset(cb_CoreInfo, rb_id2sym(rb_intern(name.c_str())), INT2FIX(std::stoi(value)));
-        } else if (name == "snapshot" || name == "static_stdlib" || name == "static_openssl") {
+        } else if (name == "snapshot" || name == "static_stdlib" || name == "static_openssl" || name == "mozilla_ca_bundle_embedded") {
             rb_hash_aset(cb_CoreInfo, rb_id2sym(rb_intern(name.c_str())), value == "true" ? Qtrue : Qfalse);
         } else {
             rb_hash_aset(cb_CoreInfo, rb_id2sym(rb_intern(name.c_str())), rb_str_freeze(rb_str_new_cstr(value.c_str())));
@@ -1253,9 +1253,7 @@ cb_map_error_code(const couchbase::core::error_context::search& ctx, const std::
     rb_hash_aset(error_context, rb_id2sym(rb_intern("error")), cb_str_new(error));
     rb_hash_aset(error_context, rb_id2sym(rb_intern("client_context_id")), cb_str_new(ctx.client_context_id));
     rb_hash_aset(error_context, rb_id2sym(rb_intern("index_name")), cb_str_new(ctx.index_name));
-    if (ctx.query) {
-        rb_hash_aset(error_context, rb_id2sym(rb_intern("query")), cb_str_new(ctx.query.value()));
-    }
+    rb_hash_aset(error_context, rb_id2sym(rb_intern("query")), cb_str_new(ctx.query));
     if (ctx.parameters) {
         rb_hash_aset(error_context, rb_id2sym(rb_intern("parameters")), cb_str_new(ctx.parameters.value()));
     }
@@ -1592,7 +1590,7 @@ extract_durability_level(VALUE options)
     if (VALUE val = rb_hash_aref(options, property_name); !NIL_P(val)) {
         ID level = rb_sym2id(val);
         if (level == rb_intern("none")) {
-            return couchbase::durability_level::none;
+            return {};
         }
         if (level == rb_intern("majority")) {
             return couchbase::durability_level::majority;
@@ -1615,7 +1613,7 @@ extract_legacy_durability_persist_to(VALUE options)
     if (VALUE val = rb_hash_aref(options, property_name); !NIL_P(val)) {
         ID mode = rb_sym2id(val);
         if (mode == rb_intern("none")) {
-            return couchbase::persist_to::none;
+            return {};
         }
         if (mode == rb_intern("active")) {
             return couchbase::persist_to::active;
@@ -1644,7 +1642,7 @@ extract_legacy_durability_replicate_to(VALUE options)
     if (VALUE val = rb_hash_aref(options, property_name); !NIL_P(val)) {
         ID mode = rb_sym2id(val);
         if (mode == rb_intern("none")) {
-            return couchbase::replicate_to::none;
+            return {};
         }
         if (mode == rb_intern("one")) {
             return couchbase::replicate_to::one;
@@ -1799,8 +1797,9 @@ cb_extract_cas(couchbase::cas& field, VALUE cas)
     }
 }
 
+template<typename Boolean>
 static void
-cb_extract_option_bool(bool& field, VALUE options, const char* name)
+cb_extract_option_bool(Boolean& field, VALUE options, const char* name)
 {
     if (!NIL_P(options) && TYPE(options) == T_HASH) {
         VALUE val = rb_hash_aref(options, rb_id2sym(rb_intern(name)));
@@ -5090,6 +5089,14 @@ cb_Backend_query_index_get_all(VALUE self, VALUE bucket_name, VALUE options)
         couchbase::core::operations::management::query_index_get_all_request req{};
         req.bucket_name = cb_string_new(bucket_name);
         cb_extract_timeout(req, options);
+        if (!NIL_P(options)) {
+            if (VALUE scope_name = rb_hash_aref(options, rb_id2sym(rb_intern("scope_name"))); TYPE(scope_name) == T_STRING) {
+                req.scope_name = cb_string_new(scope_name);
+            }
+            if (VALUE collection_name = rb_hash_aref(options, rb_id2sym(rb_intern("collection_name"))); TYPE(collection_name) == T_STRING) {
+                req.collection_name = cb_string_new(collection_name);
+            }
+        }
         auto barrier = std::make_shared<std::promise<couchbase::core::operations::management::query_index_get_all_response>>();
         auto f = barrier->get_future();
         cluster->execute(req, [barrier](couchbase::core::operations::management::query_index_get_all_response&& resp) {
@@ -5466,15 +5473,50 @@ cb_Backend_query_index_build_deferred(VALUE self, VALUE bucket_name, VALUE optio
     }
 
     try {
-        couchbase::build_query_index_options opts;
-        couchbase::ruby::set_timeout(opts, options);
-        auto bucket = cb_string_new(bucket_name);
+        couchbase::core::operations::management::query_index_build_deferred_request req{};
+        cb_extract_timeout(req, options);
+        req.bucket_name = cb_string_new(bucket_name);
 
-        auto f = couchbase::cluster(cluster).query_indexes().build_deferred_indexes(bucket, opts);
-        if (auto ctx = cb_wait_for_future(f); ctx.ec()) {
-            cb_throw_error_code(ctx, fmt::format("unable to trigger build for deferred indexes for the bucket \"{}\"", bucket));
+        if (!NIL_P(options)) {
+            if (VALUE scope_name = rb_hash_aref(options, rb_id2sym(rb_intern("scope_name"))); TYPE(scope_name) == T_STRING) {
+                req.scope_name = cb_string_new(scope_name);
+            }
+            if (VALUE collection_name = rb_hash_aref(options, rb_id2sym(rb_intern("collection_name"))); TYPE(collection_name) == T_STRING) {
+                req.collection_name = cb_string_new(collection_name);
+            }
         }
-        return Qtrue;
+
+        auto barrier = std::make_shared<std::promise<couchbase::core::operations::management::query_index_build_deferred_response>>();
+        auto f = barrier->get_future();
+        cluster->execute(req, [barrier](couchbase::core::operations::management::query_index_build_deferred_response&& resp) {
+            barrier->set_value(std::move(resp));
+        });
+        auto resp = cb_wait_for_future(f);
+        if (resp.ctx.ec) {
+            if (!resp.errors.empty()) {
+                const auto& first_error = resp.errors.front();
+                cb_throw_error_code(resp.ctx,
+                                    fmt::format(R"(unable to build deferred indexes on the bucket "{}" ({}: {}))",
+                                                req.bucket_name,
+                                                first_error.code,
+                                                first_error.message));
+            } else {
+                cb_throw_error_code(resp.ctx, fmt::format(R"(unable to build deferred indexes on the bucket "{}")", req.bucket_name));
+            }
+        }
+        VALUE res = rb_hash_new();
+        rb_hash_aset(res, rb_id2sym(rb_intern("status")), cb_str_new(resp.status));
+        if (!resp.errors.empty()) {
+            VALUE errors = rb_ary_new_capa(static_cast<long>(resp.errors.size()));
+            for (const auto& err : resp.errors) {
+                VALUE error = rb_hash_new();
+                rb_hash_aset(error, rb_id2sym(rb_intern("code")), ULL2NUM(err.code));
+                rb_hash_aset(error, rb_id2sym(rb_intern("message")), cb_str_new(err.message));
+                rb_ary_push(errors, error);
+            }
+            rb_hash_aset(res, rb_id2sym(rb_intern("errors")), errors);
+        }
+        return res;
     } catch (const std::system_error& se) {
         rb_exc_raise(cb_map_error_code(se.code(), fmt::format("failed to perform {}: {}", __func__, se.what()), false));
     } catch (const ruby_exception& e) {

data/ext/revisions.rb

@@ -1,3 +1,3 @@
-cmake_flags << "-DEXT_GIT_REVISION=527358f7c022f5fa6c93cb4d0f95118db597cc08"
-cmake_flags << "-DCOUCHBASE_CXX_CLIENT_GIT_REVISION=98af5a9a2169c9bba284d3cb1e839b6f5e54c3b8"
-cmake_flags << "-DCOUCHBASE_CXX_CLIENT_GIT_DESCRIBE=1.0.0-dp.4-22-g98af5a9"
+cmake_flags << "-DEXT_GIT_REVISION=ef79cc86f921face060319b31c7cacbecfdefaa6"
+cmake_flags << "-DCOUCHBASE_CXX_CLIENT_GIT_REVISION=2c6a065499329f39963cc3a45c87f58c6bea5f28"
+cmake_flags << "-DCOUCHBASE_CXX_CLIENT_GIT_DESCRIBE=1.0.0-dp.5-0-g2c6a065"

data/lib/couchbase/authenticator.rb

@@ -28,7 +28,6 @@ module Couchbase
     def initialize(username, password)
       @username = username
       @password = password
-      @allowed_sasl_mechanisms = DEFAULT_SASL_MECHANISMS
     end
 
     # Creates a LDAP compatible password authenticator which is INSECURE if not used with TLS.

data/lib/couchbase/cluster.rb

@@ -386,8 +386,6 @@ module Couchbase
         raise ArgumentError, "missing connection_string" unless connection_string
         raise ArgumentError, "missing username" unless credentials[:username]
         raise ArgumentError, "missing password" unless credentials[:password]
-
-        open_options[:allowed_sasl_mechanisms] = PasswordAuthenticator::DEFAULT_SASL_MECHANISMS
       else
         options = args.shift
         case options
@@ -396,8 +394,6 @@ module Couchbase
           credentials[:password] = args.shift
           raise ArgumentError, "missing username" unless credentials[:username]
           raise ArgumentError, "missing password" unless credentials[:password]
-
-          open_options[:allowed_sasl_mechanisms] = PasswordAuthenticator::DEFAULT_SASL_MECHANISMS
         when Options::Cluster
           open_options = options&.to_backend || {}
           authenticator = options&.authenticator

data/lib/couchbase/config_profiles.rb

@@ -15,7 +15,7 @@
 module Couchbase
   module ConfigProfiles
     class Profiles
-      attr :profiles
+      attr_reader :profiles
 
       def initialize
         @profiles = {}

data/lib/couchbase/json_transcoder.rb

@@ -14,18 +14,25 @@
 
 require "json"
 
+require "couchbase/transcoder_flags"
+
 module Couchbase
   class JsonTranscoder
     # @param [Object] document
     # @return [Array<String, Integer>] pair of encoded document and flags
     def encode(document)
-      [JSON.generate(document), (0x02 << 24) | 0x06]
+      raise Error::EncodingFailure, "The JsonTranscoder does not support binary data" if document.is_a?(String) && !document.valid_encoding?
+
+      [JSON.generate(document), TranscoderFlags.new(format: :json, lower_bits: 6).encode]
     end
 
-    # @param [String, nil] blob string of bytes, containing encoded representation of the document
-    # @param [Integer, :json] _flags bit field, describing how the data encoded
-    # @return Object decoded document
-    def decode(blob, _flags)
+    # @param [String] blob string of bytes, containing encoded representation of the document
+    # @param [Integer, :json] flags bit field, describing how the data encoded
+    # @return [Object] decoded document
+    def decode(blob, flags)
+      format = TranscoderFlags.decode(flags).format
+      raise Error::DecodingFailure, "Unable to decode #{format} with the JsonTranscoder" unless format == :json || format.nil?
+
       JSON.parse(blob) unless blob&.empty?
     end
   end

data/lib/couchbase/management/collection_query_index_manager.rb

@@ -14,6 +14,7 @@
 
 require "couchbase/management/query_index_manager"
 require "couchbase/utils/time"
+require "couchbase/errors"
 
 module Couchbase
   module Management
@@ -37,8 +38,18 @@ module Couchbase
       #
       # @return [Array<QueryIndex>]
       #
-      # @raise [ArgumentError]
+      # @raise [Error::InvalidArgument]
       def get_all_indexes(options = Options::Query::GetAllIndexes.new)
+        unless options.scope_name.nil?
+          raise Error::InvalidArgument,
+                "Scope name cannot be set in the options when using the Query Index manager at the collection level"
+        end
+
+        unless options.collection_name.nil?
+          raise Error::InvalidArgument,
+                "Collection name cannot be set in the options when using the Query Index manager at the collection level"
+        end
+
         res = @backend.collection_query_index_get_all(@bucket_name, @scope_name, @collection_name, options.to_backend)
         res[:indexes].map do |idx|
           QueryIndex.new do |index|
@@ -64,15 +75,17 @@ module Couchbase
       #
       # @return void
       #
-      # @raise [ArgumentError]
+      # @raise [Error::InvalidArgument]
       # @raise [Error::IndexExists]
       def create_index(index_name, fields, options = Options::Query::CreateIndex.new)
         unless options.scope_name.nil?
-          raise ArgumentError, "Scope name cannot be set in the options when using the Query Index manager at the collection level"
+          raise Error::InvalidArgument,
+                "Scope name cannot be set in the options when using the Query Index manager at the collection level"
         end
 
         unless options.collection_name.nil?
-          raise ArgumentError, "Collection name cannot be set in the options when using the Query Index manager at the collection level"
+          raise Error::InvalidArgument,
+                "Collection name cannot be set in the options when using the Query Index manager at the collection level"
         end
 
         @backend.collection_query_index_create(@bucket_name, @scope_name, @collection_name, index_name, fields, options.to_backend)
@@ -84,15 +97,17 @@ module Couchbase
       #
       # @return void
       #
-      # @raise [ArgumentError]
+      # @raise [Error::InvalidArgument]
       # @raise [Error::IndexExists]
       def create_primary_index(options = Options::Query::CreatePrimaryIndex.new)
         unless options.scope_name.nil?
-          raise ArgumentError, "Scope name cannot be set in the options when using the Query Index manager at the collection level"
+          raise Error::InvalidArgument,
+                "Scope name cannot be set in the options when using the Query Index manager at the collection level"
         end
 
         unless options.collection_name.nil?
-          raise ArgumentError, "Collection name cannot be set in the options when using the Query Index manager at the collection level"
+          raise Error::InvalidArgument,
+                "Collection name cannot be set in the options when using the Query Index manager at the collection level"
         end
 
         @backend.collection_query_index_create_primary(@bucket_name, @scope_name, @collection_name, options.to_backend)
@@ -105,15 +120,17 @@ module Couchbase
       #
       # @return void
       #
-      # @raise [ArgumentError]
+      # @raise [Error::InvalidArgument]
       # @raise [Error::IndexNotFound]
       def drop_index(index_name, options = Options::Query::DropIndex.new)
         unless options.scope_name.nil?
-          raise ArgumentError, "Scope name cannot be set in the options when using the Query Index manager at the collection level"
+          raise Error::InvalidArgument,
+                "Scope name cannot be set in the options when using the Query Index manager at the collection level"
         end
 
         unless options.collection_name.nil?
-          raise ArgumentError, "Collection name cannot be set in the options when using the Query Index manager at the collection level"
+          raise Error::InvalidArgument,
+                "Collection name cannot be set in the options when using the Query Index manager at the collection level"
         end
 
         @backend.collection_query_index_drop(@bucket_name, @scope_name, @collection_name, index_name, options.to_backend)
@@ -125,15 +142,17 @@ module Couchbase
       #
       # @return void
       #
-      # @raise [ArgumentError]
+      # @raise [Error::InvalidArgument]
       # @raise [Error::IndexNotFound]
       def drop_primary_index(options = Options::Query::DropPrimaryIndex.new)
         unless options.scope_name.nil?
-          raise ArgumentError, "Scope name cannot be set in the options when using the Query Index manager at the collection level"
+          raise Error::InvalidArgument,
+                "Scope name cannot be set in the options when using the Query Index manager at the collection level"
         end
 
         unless options.collection_name.nil?
-          raise ArgumentError, "Collection name cannot be set in the options when using the Query Index manager at the collection level"
+          raise Error::InvalidArgument,
+                "Collection name cannot be set in the options when using the Query Index manager at the collection level"
         end
 
         @backend.collection_query_index_drop_primary(@bucket_name, @scope_name, @collection_name, options.to_backend)
@@ -145,8 +164,18 @@ module Couchbase
       #
       # @return void
       #
-      # @raise [ArgumentError]
+      # @raise [Error::InvalidArgument]
       def build_deferred_indexes(options = Options::Query::BuildDeferredIndexes.new)
+        unless options.scope_name.nil?
+          raise Error::InvalidArgument,
+                "Scope name cannot be set in the options when using the Query Index manager at the collection level"
+        end
+
+        unless options.collection_name.nil?
+          raise Error::InvalidArgument,
+                "Collection name cannot be set in the options when using the Query Index manager at the collection level"
+        end
+
         @backend.collection_query_index_build_deferred(@bucket_name, @scope_name, @collection_name, options.to_backend)
       end
 
@@ -156,9 +185,19 @@ module Couchbase
       # @param [Integer, #in_milliseconds] timeout the time in milliseconds allowed for the operation to complete
       # @param [Options::Query::WatchIndexes] options
       #
-      # @raise [ArgumentError]
+      # @raise [Error::InvalidArgument]
       # @raise [Error::IndexNotFound]
       def watch_indexes(index_names, timeout, options = Options::Query::WatchIndexes.new)
+        unless options.scope_name.nil?
+          raise Error::InvalidArgument,
+                "Scope name cannot be set in the options when using the Query Index manager at the collection level"
+        end
+
+        unless options.collection_name.nil?
+          raise Error::InvalidArgument,
+                "Collection name cannot be set in the options when using the Query Index manager at the collection level"
+        end
+
         index_names.append("#primary") if options.watch_primary
 
         interval_millis = 50

data/lib/couchbase/management/query_index_manager.rb

@@ -22,21 +22,40 @@ module Couchbase
       module Query
         # Options for {QueryIndexManager#get_all_indexes}
         class GetAllIndexes < ::Couchbase::Options::Base
+          attr_accessor :scope_name # @return [String, nil]
+          attr_accessor :collection_name # @return [String, nil]
+
           # Creates an instance of options for {QueryIndexManager#get_all_indexes}
           #
+          # @param [String, nil] scope_name the name of the scope
+          # @param [String, nil] collection_name the name of the collection
+          #
           # @param [Integer, #in_milliseconds, nil] timeout the time in milliseconds allowed for the operation to complete
           # @param [Proc, nil] retry_strategy the custom retry strategy, if set
           # @param [Hash, nil] client_context the client context data, if set
           # @param [Span, nil] parent_span if set holds the parent span, that should be used for this request
           #
           # @yieldparam [GetAllScopes] self
-          def initialize(timeout: nil,
+          def initialize(scope_name: nil,
+                         collection_name: nil,
+                         timeout: nil,
                          retry_strategy: nil,
                          client_context: nil,
                          parent_span: nil)
-            super
+            super(timeout: timeout, retry_strategy: retry_strategy, client_context: client_context, parent_span: parent_span)
+            @scope_name = scope_name
+            @collection_name = collection_name
             yield self if block_given?
           end
+
+          # @api private
+          def to_backend
+            {
+              timeout: Utils::Time.extract_duration(@timeout),
+              scope_name: @scope_name,
+              collection_name: @collection_name,
+            }
+          end
         end
 
         # Options for {QueryIndexManager#create_index}
@@ -102,6 +121,7 @@ module Couchbase
           attr_accessor :ignore_if_exists # @return [Boolean]
           attr_accessor :num_replicas # @return [Integer, nil]
           attr_accessor :deferred # @return [Boolean]
+          attr_accessor :index_name # @return [String. nil]
           attr_accessor :scope_name # @return [String, nil]
           attr_accessor :collection_name # @return [String, nil]
 
@@ -110,6 +130,7 @@ module Couchbase
           # @param [Boolean] ignore_if_exists do not raise error if the index already exist
           # @param [Integer] num_replicas the number of replicas that this index should have
           # @param [Boolean] deferred whether the index should be created as a deferred index.
+          # @param [String, nil] index_name the custom name of the primary index.
           # @param [String, nil] scope_name the name of the scope
           # @param [String, nil] collection_name the name of the collection
           #
@@ -122,6 +143,7 @@ module Couchbase
           def initialize(ignore_if_exists: false,
                          num_replicas: nil,
                          deferred: false,
+                         index_name: nil,
                          scope_name: nil,
                          collection_name: nil,
                          timeout: nil,
@@ -132,6 +154,7 @@ module Couchbase
             @ignore_if_exists = ignore_if_exists
             @num_replicas = num_replicas
             @deferred = deferred
+            @index_name = index_name
             @scope_name = scope_name
             @collection_name = collection_name
             yield self if block_given?
@@ -144,6 +167,7 @@ module Couchbase
               ignore_if_exists: @ignore_if_exists,
               deferred: @deferred,
               num_replicas: @num_replicas,
+              index_name: @index_name,
               scope_name: @scope_name,
               collection_name: @collection_name,
             }
@@ -238,7 +262,12 @@ module Couchbase
 
         # Options for {QueryIndexManager#build_deferred_indexes}
         class BuildDeferredIndexes < ::Couchbase::Options::Base
+          attr_accessor :scope_name # @return [String, nil]
+          attr_accessor :collection_name # @return [String, nil]
+
           # Creates an instance of options for {QueryIndexManager#build_deferred_indexes}
+          # @param [String, nil] scope_name the name of the scope
+          # @param [String, nil] collection_name the name of the collection
           #
           # @param [Integer, #in_milliseconds, nil] timeout the time in milliseconds allowed for the operation to complete
           # @param [Proc, nil] retry_strategy the custom retry strategy, if set
@@ -246,33 +275,55 @@ module Couchbase
           # @param [Span, nil] parent_span if set holds the parent span, that should be used for this request
           #
           # @yieldparam [GetAllScopes] self
-          def initialize(timeout: nil,
+          def initialize(scope_name: nil,
+                         collection_name: nil,
+                         timeout: nil,
                          retry_strategy: nil,
                          client_context: nil,
                          parent_span: nil)
-            super
+            super(timeout: timeout, retry_strategy: retry_strategy, client_context: client_context, parent_span: parent_span)
+            @scope_name = scope_name
+            @collection_name = collection_name
             yield self if block_given?
           end
+
+          # @api private
+          def to_backend
+            {
+              timeout: Utils::Time.extract_duration(@timeout),
+              scope_name: @scope_name,
+              collection_name: @collection_name,
+            }
+          end
         end
 
         # Options for {QueryIndexManager#watch_indexes}
         class WatchIndexes < ::Couchbase::Options::Base
           attr_accessor :watch_primary # @return [Boolean]
+          attr_accessor :scope_name # @return [String, nil]
+          attr_accessor :collection_name # @return [String, nil]
 
           # Creates an instance of options for {QueryIndexManager#watch_indexes}
           #
           # @param [Boolean] watch_primary whether or not to watch the primary index
+          # @param [String, nil] scope_name the name of the scope
+          # @param [String, nil] collection_name the name of the collection
+          #
           # @param [Proc, nil] retry_strategy the custom retry strategy, if set
           # @param [Hash, nil] client_context the client context data, if set
           # @param [Span, nil] parent_span if set holds the parent span, that should be used for this request
           #
           # @yieldparam [GetAllScopes] self
           def initialize(watch_primary: false,
+                         scope_name: nil,
+                         collection_name: nil,
                          retry_strategy: nil,
                          client_context: nil,
                          parent_span: nil)
             super(timeout: nil, retry_strategy: retry_strategy, client_context: client_context, parent_span: parent_span)
             @watch_primary = watch_primary
+            @scope_name = scope_name
+            @collection_name = collection_name
             yield self if block_given?
           end
 
@@ -280,6 +331,8 @@ module Couchbase
           def to_backend
             {
               watch_primary: @watch_primary,
+              scope_name: @scope_name,
+              collection_name: @collection_name,
             }
           end
         end
@@ -343,6 +396,10 @@ module Couchbase
       #
       # @raise [ArgumentError]
       def get_all_indexes(bucket_name, options = GetAllIndexOptions.new)
+        unless options.scope_name.nil? && options.collection_name.nil?
+          warn "The attributes 'scope_name' and 'collection_name' have been deprecated. Use 'collection.query_indexes' instead"
+        end
+
         res = @backend.query_index_get_all(bucket_name, options.to_backend)
         res[:indexes].map do |idx|
           QueryIndex.new do |index|
@@ -436,10 +493,14 @@ module Couchbase
       # @param [String] bucket_name name of the bucket
       # @param [Options::Query::BuildDeferredIndexes] options
       #
-      # @return void
+      # @return
       #
       # @raise [ArgumentError]
       def build_deferred_indexes(bucket_name, options = Options::Query::BuildDeferredIndexes.new)
+        unless options.scope_name.nil? && options.collection_name.nil?
+          warn "The attributes 'scope_name' and 'collection_name' have been deprecated. Use 'collection.query_indexes' instead"
+        end
+
         @backend.query_index_build_deferred(bucket_name, options.to_backend)
       end
 
@@ -453,6 +514,10 @@ module Couchbase
       # @raise [ArgumentError]
       # @raise [Error::IndexNotFound]
       def watch_indexes(bucket_name, index_names, timeout, options = Options::Query::WatchIndexes.new)
+        unless options.scope_name.nil? && options.collection_name.nil?
+          warn "The attributes 'scope_name' and 'collection_name' have been deprecated. Use 'collection.query_indexes' instead"
+        end
+
         index_names.append("#primary") if options.watch_primary
 
         interval_millis = 50

data/lib/couchbase/raw_binary_transcoder.rb

@@ -0,0 +1,37 @@
+#  Copyright 2023. 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.
+
+require "couchbase/transcoder_flags"
+
+module Couchbase
+  class RawBinaryTranscoder
+    # @param [String] document
+    # @return [Array<String, Integer>] pair of encoded document and flags
+    def encode(document)
+      raise Error::EncodingFailure, "Only binary data supported by RawBinaryTranscoder" unless document.is_a?(String)
+
+      [document, TranscoderFlags.new(format: :binary).encode]
+    end
+
+    # @param [String] blob string of bytes, containing encoded representation of the document
+    # @param [Integer] flags bit field, describing how the data encoded
+    # @return [String] decoded document
+    def decode(blob, flags)
+      format = TranscoderFlags.decode(flags).format
+      raise Error::DecodingFailure, "Unable to decode #{format} with the RawBinaryTranscoder" unless format == :binary || format.nil?
+
+      blob
+    end
+  end
+end

data/lib/couchbase/raw_json_transcoder.rb

@@ -0,0 +1,38 @@
+#  Copyright 2023. 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.
+
+require "couchbase/transcoder_flags"
+require "couchbase/errors"
+
+module Couchbase
+  class RawJsonTranscoder
+    # @param [String] document
+    # @return [Array<String, Integer>] pair of encoded document and flags
+    def encode(document)
+      raise Error::EncodingFailure, "Only String and binary data supported by RawJsonTranscoder" unless document.is_a?(String)
+
+      [document, TranscoderFlags.new(format: :json).encode]
+    end
+
+    # @param [String] blob string of bytes, containing encoded representation of the document
+    # @param [Integer] flags bit field, describing how the data encoded
+    # @return [String] decoded document
+    def decode(blob, flags)
+      format = TranscoderFlags.decode(flags).format
+      raise Error::DecodingFailure, "Unable to decode #{format} with the RawJsonTranscoder" unless format == :json || format.nil?
+
+      blob
+    end
+  end
+end