couchbase 3.4.0-arm64-darwin-20 → 3.4.2-arm64-darwin-20

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 8a2277769a3018bb5da68ff42d71fd07a5c58bf5ddf909a44df354b1de15e3b8
-  data.tar.gz: cdbd1ea416416a893e98d8f407e7758bbad151d7f74ba5ff63e7cf43ddc27fe0
+  metadata.gz: faa96b8ef64469a07b7665a4d70a8f25cc43003361ee727c403db2514890b96b
+  data.tar.gz: 43936d9b52ce4a258d24a83111d85b4d19704d54a3ab26d5169a32c1af5d79d8
 SHA512:
-  metadata.gz: 3180001d391d32cbe4fd6a2ccb0c11c6f716e1a89ee52995d7deba670e1f7da7607a1b25199c499a7950fae2cb96cb9a278ae0884b182bf45f67310d92ce29ec
-  data.tar.gz: 12411839477ef27153db8de7a97e1fb81cb88259e5e0a9964b2ea510b65c47110eaa20f44d07013c0353f74ec258f385114eefcc1a6d6b33a13c688d067caaab
+  metadata.gz: 6ca2f3e4cd54458cc4b4ee6399d79ba31e716640f1727aaee9f37d8916a3de13f5cdcb8e4a4849fa4c9d50b6bbe982ed8c728351b957fa4f5484ae96d96ba891
+  data.tar.gz: 712cf52caa8edfeb978c879575f204d44c69f42f9867d1b2232337d6ce103a4407669136ad27619e721c35f0b2802b6530966662b0d0806bc45aad59810ed1b1

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.2"
 ```
 
 And then execute:
@@ -139,7 +139,7 @@ Now the API reference is accessible using a web browser (where `VERSION` is the
 
 The gem is available as open source under the terms of the [Apache2 License](https://opensource.org/licenses/Apache-2.0).
 
-    Copyright 2011-2021 Couchbase, Inc.
+    Copyright 2011-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.

data/lib/couchbase/binary_collection.rb

@@ -38,7 +38,7 @@ module Couchbase
     #   collection.get("mydoc", Options::Get(transcoder: nil)).content #=> "foobar"
     #
     # @return [Collection::MutationResult]
-    def append(id, content, options = Options::Append.new)
+    def append(id, content, options = Options::Append::DEFAULT)
       resp = @backend.document_append(@collection.bucket_name, @collection.scope_name, @collection.name,
                                       id, content, options.to_backend)
       Collection::MutationResult.new do |res|
@@ -59,7 +59,7 @@ module Couchbase
     #   collection.get("mydoc", Options::Get(transcoder: nil)).content #=> "barfoo"
     #
     # @return [Collection::MutationResult]
-    def prepend(id, content, options = Options::Prepend.new)
+    def prepend(id, content, options = Options::Prepend::DEFAULT)
       resp = @backend.document_prepend(@collection.bucket_name, @collection.scope_name, @collection.name,
                                        id, content, options.to_backend)
       Collection::MutationResult.new do |res|
@@ -80,7 +80,7 @@ module Couchbase
     #   res.content #=> 10
     #
     # @return [CounterResult]
-    def increment(id, options = Options::Increment.new)
+    def increment(id, options = Options::Increment::DEFAULT)
       resp = @backend.document_increment(@collection.bucket_name, @collection.scope_name, @collection.name, id,
                                          options.to_backend)
       CounterResult.new do |res|
@@ -102,7 +102,7 @@ module Couchbase
     #   res.value #=> 98
     #
     # @return [CounterResult]
-    def decrement(id, options = Options::Decrement.new)
+    def decrement(id, options = Options::Decrement::DEFAULT)
       resp = @backend.document_decrement(@collection.bucket_name, @collection.scope_name, @collection.name, id,
                                          options.to_backend)
       CounterResult.new do |res|

data/lib/couchbase/cluster.rb

@@ -32,13 +32,13 @@ module Couchbase
 
     # Connect to the Couchbase cluster
     #
-    # @overload connect(connection_string, options)
-    #   @param [String] connection_string connection string used to locate the Couchbase Cluster
+    # @overload connect(connection_string_or_config, options)
+    #   @param [String, Configuration] connection_string_or_config connection string used to locate the Couchbase Cluster
     #   @param [Options::Cluster] options custom options when creating the cluster connection
     #
-    # @overload connect(connection_string, username, password, options)
+    # @overload connect(connection_string_or_config, username, password, options)
     #   Shortcut for {PasswordAuthenticator}
-    #   @param [String] connection_string connection string used to locate the Couchbase Cluster
+    #   @param [String] connection_string_or_config connection string used to locate the Couchbase Cluster
     #   @param [String] username name of the user
     #   @param [String] password password of the user
     #   @param [Options::Cluster, nil] options custom options when creating the cluster connection
@@ -62,12 +62,16 @@ module Couchbase
     # @see https://docs.couchbase.com/server/current/manage/manage-security/configure-client-certificates.html
     #
     # @return [Cluster]
-    def self.connect(connection_string, *options)
-      regexp = /^((couchbases?|http):\/\/.*)$/i
-      if regexp.match?(connection_string) || !connection_string.include?("://")
-        Cluster.new(connection_string, *options)
+    def self.connect(connection_string_or_config, *options)
+      connection_string = if connection_string_or_config.is_a?(Configuration)
+                            connection_string_or_config.connection_string
+                          else
+                            connection_string_or_config
+                          end
+      if connection_string =~ /\Acouchbases?:\/\/.*\z/i || !connection_string.include?("://")
+        Cluster.new(connection_string_or_config, *options)
       else
-        ClusterRegistry.instance.connect(connection_string, *options)
+        ClusterRegistry.instance.connect(connection_string_or_config, *options)
       end
     end
 

data/lib/couchbase/cluster_registry.rb

@@ -26,9 +26,14 @@ module Couchbase
       @handlers = {}
     end
 
-    def connect(connection_string, *options)
+    def connect(connection_string_or_config, *options)
+      connection_string = if connection_string_or_config.is_a?(Configuration)
+                            connection_string_or_config.connection_string
+                          else
+                            connection_string_or_config
+                          end
       @handlers.each do |regexp, cluster_class|
-        return cluster_class.connect(connection_string, *options) if regexp.match?(connection_string)
+        return cluster_class.connect(connection_string_or_config, *options) if regexp.match?(connection_string)
       end
       raise(Error::FeatureNotAvailable, "Connection string '#{connection_string}' not supported.")
     end

data/lib/couchbase/collection.rb

@@ -43,6 +43,11 @@ module Couchbase
       BinaryCollection.new(self)
     end
 
+    # @return [Management::CollectionQueryIndexManager]
+    def query_indexes
+      Management::CollectionQueryIndexManager.new(@backend, @bucket_name, @scope_name, @name)
+    end
+
     # Fetches the full document from the collection
     #
     # @param [String] id the document id which is used to uniquely identify it

data/lib/couchbase/configuration.rb

@@ -33,10 +33,9 @@ module Couchbase
     private
 
     def load_configuration(settings)
-      configuration = settings.with_indifferent_access
-      @connection_string = configuration[:connection_string]
-      @username = configuration[:username]
-      @password = configuration[:password]
+      @connection_string = settings[:connection_string] || settings["connection_string"]
+      @username = settings[:username] || settings["username"]
+      @password = settings[:password] || settings["password"]
     end
 
     def load_yaml(path, environment)

data/lib/couchbase/errors.rb

@@ -21,6 +21,11 @@ module Couchbase
       # @return [Hash] attributes associated with the error
       attr_reader :context
 
+      def initialize(msg = nil, context = nil)
+        @context = context unless context.nil?
+        super(msg)
+      end
+
       def to_s
         defined?(@context) ? "#{super}, context=#{JSON.generate(@context)}" : super
       end
@@ -30,6 +35,11 @@ module Couchbase
       # @return [Hash] attributes associated with the error
       attr_reader :context
 
+      def initialize(msg = nil, context = nil)
+        @context = context unless context.nil?
+        super(msg)
+      end
+
       def to_s
         defined?(@context) ? "#{super}, context=#{JSON.generate(@context)}" : super
       end

data/lib/couchbase/management/collection_query_index_manager.rb

@@ -0,0 +1,183 @@
+#  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/management/query_index_manager"
+require "couchbase/utils/time"
+
+module Couchbase
+  module Management
+    class CollectionQueryIndexManager
+      alias inspect to_s
+
+      # @param [Couchbase::Backend] backend
+      # @param [String] bucket_name name of the bucket
+      # @param [String] scope_name name of the scope
+      # @param [String] collection_name name of the collection
+      def initialize(backend, bucket_name, scope_name, collection_name)
+        @backend = backend
+        @bucket_name = bucket_name
+        @scope_name = scope_name
+        @collection_name = collection_name
+      end
+
+      # Fetches all indexes from the server
+      #
+      # @param [Options::Query::GetAllIndexes] options
+      #
+      # @return [Array<QueryIndex>]
+      #
+      # @raise [ArgumentError]
+      def get_all_indexes(options = Options::Query::GetAllIndexes.new)
+        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|
+            index.name = idx[:name]
+            index.is_primary = idx[:is_primary]
+            index.type = idx[:type]
+            index.state = idx[:state]
+            index.bucket = idx[:bucket_name]
+            index.scope = idx[:scope_name]
+            index.collection = idx[:collection_name]
+            index.index_key = idx[:index_key]
+            index.condition = idx[:condition]
+            index.partition = idx[:partition]
+          end
+        end
+      end
+
+      # Creates a new index
+      #
+      # @param [String] index_name name of the index
+      # @param [Array<String>] fields the lists of fields to create th index over
+      # @param [Options::Query::CreateIndex] options
+      #
+      # @return void
+      #
+      # @raise [ArgumentError]
+      # @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"
+        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"
+        end
+
+        @backend.collection_query_index_create(@bucket_name, @scope_name, @collection_name, index_name, fields, options.to_backend)
+      end
+
+      # Creates new primary index
+      #
+      # @param [Options::Query::CreatePrimaryIndex] options
+      #
+      # @return void
+      #
+      # @raise [ArgumentError]
+      # @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"
+        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"
+        end
+
+        @backend.collection_query_index_create_primary(@bucket_name, @scope_name, @collection_name, options.to_backend)
+      end
+
+      # Drops the index
+      #
+      # @param [String] index_name name of the index
+      # @param [Options::Query::DropIndex] options
+      #
+      # @return void
+      #
+      # @raise [ArgumentError]
+      # @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"
+        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"
+        end
+
+        @backend.collection_query_index_drop(@bucket_name, @scope_name, @collection_name, index_name, options.to_backend)
+      end
+
+      # Drops the primary index
+      #
+      # @param [Options::Query::DropPrimaryIndex] options
+      #
+      # @return void
+      #
+      # @raise [ArgumentError]
+      # @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"
+        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"
+        end
+
+        @backend.collection_query_index_drop_primary(@bucket_name, @scope_name, @collection_name, options.to_backend)
+      end
+
+      # Build all indexes which are currently in deferred state
+      #
+      # @param [Options::Query::BuildDeferredIndexes] options
+      #
+      # @return void
+      #
+      # @raise [ArgumentError]
+      def build_deferred_indexes(options = Options::Query::BuildDeferredIndexes.new)
+        @backend.collection_query_index_build_deferred(@bucket_name, @scope_name, @collection_name, options.to_backend)
+      end
+
+      # Polls indexes until they are online
+      #
+      # @param [Array<String>] index_names names of the indexes to watch
+      # @param [Integer, #in_milliseconds] timeout the time in milliseconds allowed for the operation to complete
+      # @param [Options::Query::WatchIndexes] options
+      #
+      # @raise [ArgumentError]
+      # @raise [Error::IndexNotFound]
+      def watch_indexes(index_names, timeout, options = Options::Query::WatchIndexes.new)
+        index_names.append("#primary") if options.watch_primary
+
+        interval_millis = 50
+        deadline = Time.now + (Utils::Time.extract_duration(timeout) * 0.001)
+        while Time.now <= deadline
+          get_all_opts = Options::Query::GetAllIndexes.new(timeout: ((deadline - Time.now) * 1000).round)
+          indexes = get_all_indexes(get_all_opts).select { |idx| index_names.include? idx.name }
+          indexes_not_found = index_names - indexes.map(&:name)
+          raise Error::IndexNotFound, "Failed to find the indexes: #{indexes_not_found.join(', ')}" unless indexes_not_found.empty?
+
+          all_online = indexes.all? { |idx| idx.state == :online }
+          return if all_online
+
+          sleep(interval_millis / 1000)
+          interval_millis += 500
+          interval_millis = 1000 if interval_millis > 1000
+        end
+        raise Error::UnambiguousTimeout, "Failed to find all indexes online within the allotted time"
+      end
+    end
+  end
+end

data/lib/couchbase/management/query_index_manager.rb

@@ -14,6 +14,7 @@
 
 require "couchbase/errors"
 require "couchbase/options"
+require "couchbase/utils/time"
 
 module Couchbase
   module Management
@@ -371,6 +372,10 @@ module Couchbase
       # @raise [ArgumentError]
       # @raise [Error::IndexExists]
       def create_index(bucket_name, index_name, fields, options = Options::Query::CreateIndex.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_create(bucket_name, index_name, fields, options.to_backend)
       end
 
@@ -384,6 +389,10 @@ module Couchbase
       # @raise [ArgumentError]
       # @raise [Error::IndexExists]
       def create_primary_index(bucket_name, options = Options::Query::CreatePrimaryIndex.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_create_primary(bucket_name, options.to_backend)
       end
 
@@ -398,8 +407,11 @@ module Couchbase
       # @raise [ArgumentError]
       # @raise [Error::IndexNotFound]
       def drop_index(bucket_name, index_name, options = Options::Query::DropIndex.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_drop(bucket_name, index_name, options.to_backend)
-        true
       end
 
       # Drops the primary index
@@ -412,8 +424,11 @@ module Couchbase
       # @raise [ArgumentError]
       # @raise [Error::IndexNotFound]
       def drop_primary_index(bucket_name, options = Options::Query::DropPrimaryIndex.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_drop_primary(bucket_name, options.to_backend)
-        true
       end
 
       # Build all indexes which are currently in deferred state
@@ -438,7 +453,24 @@ module Couchbase
       # @raise [ArgumentError]
       # @raise [Error::IndexNotFound]
       def watch_indexes(bucket_name, index_names, timeout, options = Options::Query::WatchIndexes.new)
-        @backend.query_index_watch(bucket_name, index_names, Utils::Time.extract_duration(timeout), options.to_backend)
+        index_names.append("#primary") if options.watch_primary
+
+        interval_millis = 50
+        deadline = Time.now + (Utils::Time.extract_duration(timeout) * 0.001)
+        while Time.now <= deadline
+          get_all_opts = Options::Query::GetAllIndexes.new(timeout: ((deadline - Time.now) * 1000).round)
+          indexes = get_all_indexes(bucket_name, get_all_opts).select { |idx| index_names.include? idx.name }
+          indexes_not_found = index_names - indexes.map(&:name)
+          raise Error::IndexNotFound, "Failed to find the indexes: #{indexes_not_found.join(', ')}" unless indexes_not_found.empty?
+
+          all_online = indexes.all? { |idx| idx.state == :online }
+          return if all_online
+
+          sleep(interval_millis / 1000)
+          interval_millis += 500
+          interval_millis = 1000 if interval_millis > 1000
+        end
+        raise Error::UnambiguousTimeout, "Failed to find all indexes online within the allotted time"
       end
 
       # @api private

data/lib/couchbase/management.rb

@@ -22,6 +22,7 @@ require "couchbase/management/analytics_index_manager"
 require "couchbase/management/bucket_manager"
 require "couchbase/management/collection_manager"
 require "couchbase/management/query_index_manager"
+require "couchbase/management/collection_query_index_manager"
 require "couchbase/management/search_index_manager"
 require "couchbase/management/user_manager"
 require "couchbase/management/view_index_manager"

data/lib/couchbase/options.rb

@@ -1029,10 +1029,38 @@ module Couchbase
     # Options for {BinaryCollection#append}
     class Append < Base
       attr_accessor :cas # @return [Integer]
+      attr_accessor :durability_level # @return [Symbol]
+      attr_accessor :replicate_to # @return [Symbol]
+      attr_accessor :persist_to # @return [Symbol]
 
       # Creates an instance of options for {BinaryCollection#append}
       #
       # @param [Integer] cas The default CAS used (0 means no CAS in this context)
+      # @param [Symbol] durability_level level of durability
+      #  +:none+::
+      #     no enhanced durability required for the mutation
+      #  +:majority+::
+      #     the mutation must be replicated to a majority of the Data Service nodes
+      #     (that is, held in the memory allocated to the bucket)
+      #  +:majority_and_persist_to_active+::
+      #     The mutation must be replicated to a majority of the Data Service nodes.
+      #     Additionally, it must be persisted (that is, written and synchronised to disk) on the
+      #     node hosting the active partition (vBucket) for the data.
+      #  +:persist_to_majority+::
+      #     The mutation must be persisted to a majority of the Data Service nodes.
+      #     Accordingly, it will be written to disk on those nodes.
+      # @param [Symbol] replicate_to number of nodes to replicate
+      #  +:none+:: do not apply any replication requirements.
+      #  +:one+::  wait for replication to at least one node.
+      #  +:two+::  wait for replication to at least two nodes.
+      #  +:three+:: wait for replication to at least three nodes.
+      # @param [Symbol] persist_to number of nodes to persist
+      #  +:none+:: do not apply any persistence requirements.
+      #  +:active+::  wait for persistence to active node
+      #  +:one+::  wait for persistence to at least one node.
+      #  +:two+:: wait for persistence to at least two nodes.
+      #  +:three+:: wait for persistence to at least three nodes.
+      #  +:four+:: wait for persistence to four nodes (active and replicas).
       #
       # @param [Integer, #in_milliseconds, nil] timeout
       # @param [Proc, nil] retry_strategy the custom retry strategy, if set
@@ -1041,12 +1069,23 @@ module Couchbase
       #
       # @yieldparam [Append] self
       def initialize(cas: nil,
+                     durability_level: :none,
+                     replicate_to: :none,
+                     persist_to: :none,
                      timeout: nil,
                      retry_strategy: nil,
                      client_context: nil,
                      parent_span: nil)
         super(timeout: timeout, retry_strategy: retry_strategy, client_context: client_context, parent_span: parent_span)
         @cas = cas
+
+        if durability_level != :none && (replicate_to != :none || persist_to != :none)
+          raise ArgumentError, "durability_level conflicts with replicate_to and persist_to options"
+        end
+
+        @durability_level = durability_level
+        @replicate_to = replicate_to
+        @persist_to = persist_to
         yield self if block_given?
       end
 
@@ -1055,6 +1094,9 @@ module Couchbase
         {
           timeout: Utils::Time.extract_duration(@timeout),
           cas: @cas,
+          durability_level: @durability_level,
+          persist_to: @persist_to,
+          replicate_to: @replicate_to,
         }
       end
 
@@ -1064,12 +1106,39 @@ module Couchbase
 
     # Options for {BinaryCollection#prepend}
     class Prepend < Base
-      # @return [Integer] The default CAS used (0 means no CAS in this context)
-      attr_accessor :cas
+      attr_accessor :cas # @return [Integer]
+      attr_accessor :durability_level # @return [Symbol]
+      attr_accessor :replicate_to # @return [Symbol]
+      attr_accessor :persist_to # @return [Symbol]
 
       # Creates an instance of options for {BinaryCollection#prepend}
       #
       # @param [Integer] cas The default CAS used (0 means no CAS in this context)
+      # @param [Symbol] durability_level level of durability
+      #  +:none+::
+      #     no enhanced durability required for the mutation
+      #  +:majority+::
+      #     the mutation must be replicated to a majority of the Data Service nodes
+      #     (that is, held in the memory allocated to the bucket)
+      #  +:majority_and_persist_to_active+::
+      #     The mutation must be replicated to a majority of the Data Service nodes.
+      #     Additionally, it must be persisted (that is, written and synchronised to disk) on the
+      #     node hosting the active partition (vBucket) for the data.
+      #  +:persist_to_majority+::
+      #     The mutation must be persisted to a majority of the Data Service nodes.
+      #     Accordingly, it will be written to disk on those nodes.
+      # @param [Symbol] replicate_to number of nodes to replicate
+      #  +:none+:: do not apply any replication requirements.
+      #  +:one+::  wait for replication to at least one node.
+      #  +:two+::  wait for replication to at least two nodes.
+      #  +:three+:: wait for replication to at least three nodes.
+      # @param [Symbol] persist_to number of nodes to persist
+      #  +:none+:: do not apply any persistence requirements.
+      #  +:active+::  wait for persistence to active node
+      #  +:one+::  wait for persistence to at least one node.
+      #  +:two+:: wait for persistence to at least two nodes.
+      #  +:three+:: wait for persistence to at least three nodes.
+      #  +:four+:: wait for persistence to four nodes (active and replicas).
       #
       # @param [Integer, #in_milliseconds, nil] timeout
       # @param [Proc, nil] retry_strategy the custom retry strategy, if set
@@ -1078,12 +1147,23 @@ module Couchbase
       #
       # @yieldparam [Prepend] self
       def initialize(cas: nil,
+                     durability_level: :none,
+                     replicate_to: :none,
+                     persist_to: :none,
                      timeout: nil,
                      retry_strategy: nil,
                      client_context: nil,
                      parent_span: nil)
         super(timeout: timeout, retry_strategy: retry_strategy, client_context: client_context, parent_span: parent_span)
         @cas = cas
+
+        if durability_level != :none && (replicate_to != :none || persist_to != :none)
+          raise ArgumentError, "durability_level conflicts with replicate_to and persist_to options"
+        end
+
+        @durability_level = durability_level
+        @replicate_to = replicate_to
+        @persist_to = persist_to
         yield self if block_given?
       end
 
@@ -1092,6 +1172,9 @@ module Couchbase
         {
           timeout: Utils::Time.extract_duration(@timeout),
           cas: @cas,
+          durability_level: @durability_level,
+          persist_to: @persist_to,
+          replicate_to: @replicate_to,
         }
       end
 
@@ -2091,7 +2174,7 @@ module Couchbase
       attr_reader :scan_consistency
 
       # @api private
-      def to_backend(scope_name: nil)
+      def to_backend(*)
         {
           timeout: Utils::Time.extract_duration(@timeout),
           limit: @limit,
@@ -2099,8 +2182,7 @@ module Couchbase
           explain: @explain,
           disable_scoring: @disable_scoring,
           include_locations: @include_locations,
-          scope: scope_name,
-          collections: scope_name ? @collections : nil,
+          collections: @collections,
           highlight_style: @highlight_style,
           highlight_fields: @highlight_fields,
           fields: @fields,