couchbase 3.0.0.alpha.1-universal-darwin-19 → 3.0.0.beta.1-universal-darwin-19

data/lib/couchbase/cluster.rb

@@ -12,14 +12,18 @@
 #  See the License for the specific language governing permissions and
 #  limitations under the License.
 
-require 'couchbase/authenticator'
-require 'couchbase/bucket'
+require "couchbase/authenticator"
+require "couchbase/bucket"
 
-require 'couchbase/management/user_manager'
-require 'couchbase/management/bucket_manager'
-require 'couchbase/management/query_index_manager'
-require 'couchbase/management/analytics_index_manager'
-require 'couchbase/management/search_index_manager'
+require "couchbase/management/user_manager"
+require "couchbase/management/bucket_manager"
+require "couchbase/management/query_index_manager"
+require "couchbase/management/analytics_index_manager"
+require "couchbase/management/search_index_manager"
+
+require "couchbase/search_options"
+require "couchbase/query_options"
+require "couchbase/analytics_options"
 
 module Couchbase
   class Cluster
@@ -35,29 +39,46 @@ module Couchbase
       Cluster.new(connection_string, options)
     end
 
+    # Returns an instance of the {Bucket}
+    #
+    # @param [String] name name of the bucket
+    #
+    # @return [Bucket]
     def bucket(name)
       Bucket.new(@backend, name)
     end
 
     # Performs a query against the query (N1QL) services
-    # 
+    #
     # @param [String] statement the N1QL query statement
     # @param [QueryOptions] options the custom options for this query
     #
     # @return [QueryResult]
     def query(statement, options = QueryOptions.new)
-      resp = @backend.query(statement, {
+      resp = @backend.document_query(statement, {
+          timeout: options.timeout,
           adhoc: options.adhoc,
           client_context_id: options.client_context_id,
           max_parallelism: options.max_parallelism,
           readonly: options.readonly,
+          scan_wait: options.scan_wait,
           scan_cap: options.scan_cap,
           pipeline_batch: options.pipeline_batch,
           pipeline_cap: options.pipeline_cap,
           metrics: options.metrics,
           profile: options.profile,
-          positional_parameters: options.instance_variable_get("@positional_parameters")&.map { |p| JSON.dump(p) },
-          named_parameters: options.instance_variable_get("@named_parameters")&.each_with_object({}) { |(n, v), o| o[n.to_s] = JSON.dump(v) }
+          positional_parameters: options.export_positional_parameters,
+          named_parameters: options.export_named_parameters,
+          raw_parameters: options.raw_parameters,
+          scan_consistency: options.scan_consistency,
+          mutation_state: (options.mutation_state.tokens.map { |t|
+            {
+                bucket_name: t.bucket_name,
+                partition_id: t.partition_id,
+                partition_uuid: t.partition_uuid,
+                sequence_number: t.sequence_number,
+            }
+          } if options.mutation_state),
       })
 
       QueryResult.new do |res|
@@ -73,6 +94,7 @@ module Couchbase
               metrics.execution_time = resp[:meta][:metrics][:execution_time]
               metrics.sort_count = resp[:meta][:metrics][:sort_count]
               metrics.result_count = resp[:meta][:metrics][:result_count]
+              metrics.result_size = resp[:meta][:metrics][:result_size]
               metrics.mutation_count = resp[:meta][:metrics][:mutation_count]
               metrics.error_count = resp[:meta][:metrics][:error_count]
               metrics.warning_count = resp[:meta][:metrics][:warning_count]
@@ -85,12 +107,47 @@ module Couchbase
     end
 
     # Performs an analytics query
-    # 
+    #
     # @param [String] statement the N1QL query statement
     # @param [AnalyticsOptions] options the custom options for this query
     #
     # @return [AnalyticsResult]
-    def analytics_query(statement, options = AnalyticsOptions.new) end
+    def analytics_query(statement, options = AnalyticsOptions.new)
+      resp = @backend.document_analytics(statement, {
+          timeout: options.timeout,
+          client_context_id: options.client_context_id,
+          scan_consistency: options.scan_consistency,
+          readonly: options.readonly,
+          priority: options.priority,
+          positional_parameters: options.export_positional_parameters,
+          named_parameters: options.export_named_parameters,
+          raw_parameters: options.raw_parameters,
+      })
+
+      AnalyticsResult.new do |res|
+        res.transcoder = options.transcoder
+        res.meta_data = AnalyticsMetaData.new do |meta|
+          meta.status = resp[:meta][:status]
+          meta.request_id = resp[:meta][:request_id]
+          meta.client_context_id = resp[:meta][:client_context_id]
+          meta.signature = JSON.parse(resp[:meta][:signature]) if resp[:meta][:signature]
+          meta.profile = JSON.parse(resp[:meta][:profile]) if resp[:meta][:profile]
+          meta.metrics = AnalyticsMetrics.new do |metrics|
+            if resp[:meta][:metrics]
+              metrics.elapsed_time = resp[:meta][:metrics][:elapsed_time]
+              metrics.execution_time = resp[:meta][:metrics][:execution_time]
+              metrics.result_count = resp[:meta][:metrics][:result_count]
+              metrics.result_size = resp[:meta][:metrics][:result_size]
+              metrics.error_count = resp[:meta][:metrics][:error_count]
+              metrics.warning_count = resp[:meta][:metrics][:warning_count]
+              metrics.processed_objects = resp[:meta][:metrics][:processed_objects]
+            end
+          end
+          res[:warnings] = resp[:warnings].map { |warn| QueryWarning.new(warn[:code], warn[:message]) } if resp[:warnings]
+        end
+        res.instance_variable_set("@rows", resp[:rows])
+      end
+    end
 
     # Performs a Full Text Search (FTS) query
     #
@@ -98,27 +155,133 @@ module Couchbase
     # @param [SearchQuery] query the query tree
     # @param [SearchOptions] options the query tree
     #
-    # @return [QueryResult]
-    def search_query(index_name, query, options = SearchOptions.new) end
+    # @return [SearchResult]
+    def search_query(index_name, query, options = SearchOptions.new)
+      resp = @backend.document_search(index_name, JSON.generate(query), {
+          timeout: options.timeout,
+          limit: options.limit,
+          skip: options.skip,
+          explain: options.explain,
+          highlight_style: options.highlight_style,
+          highlight_fields: options.highlight_fields,
+          fields: options.fields,
+          sort: (options.sort.map { |v| JSON.generate(v) } if options.sort),
+          facets: (options.facets.map { |(k, v)| [k, JSON.generate(v)] } if options.facets),
+          scan_consistency: options.scan_consistency,
+          mutation_state: (options.mutation_state.tokens.map { |t|
+            {
+                bucket_name: t.bucket_name,
+                partition_id: t.partition_id,
+                partition_uuid: t.partition_uuid,
+                sequence_number: t.sequence_number,
+            }
+          } if options.mutation_state),
+      })
+
+      SearchResult.new do |res|
+        res.meta_data = SearchMetaData.new do |meta|
+          meta.metrics.max_score = resp[:meta_data][:metrics][:max_score]
+          meta.metrics.error_partition_count = resp[:meta_data][:metrics][:error_partition_count]
+          meta.metrics.success_partition_count = resp[:meta_data][:metrics][:success_partition_count]
+          meta.metrics.took = resp[:meta_data][:metrics][:took]
+          meta.metrics.total_rows = resp[:meta_data][:metrics][:total_rows]
+        end
+        res.rows = resp[:rows].map do |r|
+          SearchRow.new do |row|
+            row.transcoder = options.transcoder
+            row.index = r[:index]
+            row.id = r[:id]
+            row.score = r[:score]
+            row.fragments = r[:fragments]
+            row.locations = SearchRowLocations.new(
+                r[:locations].map do |loc|
+                  SearchRowLocation.new do |location|
+                    location.field = loc[:field]
+                    location.term = loc[:term]
+                    location.position = loc[:position]
+                    location.start_offset = loc[:start_offset]
+                    location.end_offset = loc[:end_offset]
+                    location.array_positions = loc[:array_positions]
+                  end
+                end
+            )
+            row.instance_variable_set("@fields", r[:fields])
+            row.explanation = JSON.parse(r[:explanation]) if r[:explanation]
+          end
+        end
+        if resp[:facets]
+          res.facets = resp[:facets].each_with_object({}) do |(k, v), o|
+            facet = case options.facets[k]
+                    when SearchFacet::SearchFacetTerm
+                      SearchFacetResult::TermFacetResult.new do |f|
+                        f.terms =
+                            if v[:terms]
+                              v[:terms].map do |t|
+                                SearchFacetResult::TermFacetResult::TermFacet.new(t[:term], t[:count])
+                              end
+                            else
+                              []
+                            end
+                      end
+                    when SearchFacet::SearchFacetDateRange
+                      SearchFacetResult::DateRangeFacetResult.new do |f|
+                        f.date_ranges =
+                            if v[:date_ranges]
+                              v[:date_ranges].map do |r|
+                                SearchFacetResult::DateRangeFacetResult::DateRangeFacet.new(r[:name], r[:count], r[:start_time], r[:end_time])
+                              end
+                            else
+                              []
+                            end
+                      end
+                    when SearchFacet::SearchFacetNumericRange
+                      SearchFacetResult::NumericRangeFacetResult.new do |f|
+                        f.numeric_ranges =
+                            if v[:numeric_ranges]
+                              v[:numeric_ranges].map do |r|
+                                SearchFacetResult::NumericRangeFacetResult::NumericRangeFacet.new(r[:name], r[:count], r[:min], r[:max])
+                              end
+                            else
+                              []
+                            end
+                      end
+                    else
+                      next # ignore unknown facet result
+                    end
+            facet.name = v[:name]
+            facet.field = v[:field]
+            facet.total = v[:total]
+            facet.missing = v[:missing]
+            facet.other = v[:other]
+            o[k] = facet
+          end
+        end
+      end
+    end
 
+    # @return [Management::UserManager]
     def users
-      UserManager.new(@backend)
+      Management::UserManager.new(@backend)
     end
 
+    # @return [Management::BucketManager]
     def buckets
-      BucketManager.new(@backend)
+      Management::BucketManager.new(@backend)
     end
 
+    # @return [Management::QueryIndexManager]
     def query_indexes
-      QueryIndexManager.new(@backend)
+      Management::QueryIndexManager.new(@backend)
     end
 
+    # @return [Management::AnalyticsIndexManager]
     def analytics_indexes
-      AnalyticsIndexManager.new(@backend)
+      Management::AnalyticsIndexManager.new(@backend)
     end
 
+    # @return [Management::SearchIndexManager]
     def search_indexes
-      SearchIndexManager.new(@backend)
+      Management::SearchIndexManager.new(@backend)
     end
 
     def disconnect
@@ -140,95 +303,6 @@ module Couchbase
       end
     end
 
-    class QueryOptions
-      # @return [Boolean] Allows turning this request into a prepared statement query
-      attr_accessor :adhoc
-
-      # @return [String] Provides a custom client context ID for this query
-      attr_accessor :client_context_id
-
-      # @return [Integer] Allows overriding the default maximum parallelism for the query execution on the server side.
-      attr_accessor :max_parallelism
-
-      # @return [Boolean] Allows explicitly marking a query as being readonly and not mutating and documents on the server side.
-      attr_accessor :readonly
-
-      # @return [Integer] Supports customizing the maximum buffered channel size between the indexer and the query service
-      attr_accessor :scan_cap
-
-      # @return [Integer] Supports customizing the number of items execution operators can batch for fetch from the KV layer on the server.
-      attr_accessor :pipeline_batch
-
-      # @return [Integer] Allows customizing the maximum number of items each execution operator can buffer between various operators on the server.
-      attr_accessor :pipeline_cap
-
-      # @return [Boolean] Enables per-request metrics in the trailing section of the query
-      attr_accessor :metrics
-
-      # @return [:off, :phases, :timings] Customize server profile level for this query
-      attr_accessor :profile
-
-      def initialize
-        @adhoc = true
-        yield self if block_given?
-        @positional_parameters = nil
-        @named_parameters = nil
-      end
-
-      # Allows providing custom JSON key/value pairs for advanced usage
-      #
-      # @param [String] key the parameter name (key of the JSON property)
-      # @param [Object] value the parameter value (value of the JSON property)
-      def raw(key, value) end
-
-      # Customizes the consistency guarantees for this query
-      #
-      # * +:not_bounded+ The indexer will return whatever state it has to the query engine at the time of query. This is the default (for single-statement requests).
-      #
-      # * +:request_plus+ The indexer will wait until all mutations have been processed at the time of request before returning to the query engine.
-      #
-      # @param [:not_bounded, :request_plus] scan_consistency the index scan consistency to be used for this query
-      def scan_consistency=(level)
-        @scan_consistency = level
-      end
-
-      # Sets the mutation tokens this query should be consistent with
-      #
-      #
-      # @param [MutationState] the mutation state containing the mutation tokens
-      def consistent_with(mutation_state)
-        @mutation_state = mutation_state
-      end
-
-      # Sets positional parameters for the query
-      #
-      # @param [Array] positional the list of parameters that have to be substituted in the statement
-      def positional_parameters(positional)
-        @positional_parameters = positional
-        @named_parameters = nil
-      end
-
-      # Sets named parameters for the query
-      #
-      # @param [Hash] named the key/value map of the parameters to substitute in the statement
-      def named_parameters(named)
-        @named_parameters = named
-        @positional_parameters = nil
-      end
-    end
-
-    class AnalyticsOptions
-      def initialize
-        yield self if block_given?
-      end
-    end
-
-    class SearchOptions
-      def initialize
-        yield self if block_given?
-      end
-    end
-
     class DiagnosticsOptions
       # @return [String] Holds custom report id.
       attr_accessor :report_id
@@ -240,9 +314,11 @@ module Couchbase
 
     private
 
+    # Initialize {Cluster} object
+    #
+    # @param [String] connection_string connection string used to locate the Couchbase Cluster
+    # @param [ClusterOptions] options custom options when creating the cluster connection
     def initialize(connection_string, options)
-      hostname = connection_string[%r{^couchbase://(.*)}, 1]
-      raise ArgumentError, "missing hostname" unless hostname
       raise ArgumentError, "options must have authenticator configured" unless options.authenticator
       username = options.authenticator.username
       raise ArgumentError, "missing username" unless username
@@ -250,7 +326,7 @@ module Couchbase
       raise ArgumentError, "missing password" unless password
 
       @backend = Backend.new
-      @backend.open(hostname, username, password)
+      @backend.open(connection_string, username, password, {})
     end
   end
-end
+end

data/lib/couchbase/collection.rb

@@ -12,9 +12,9 @@
 #  See the License for the specific language governing permissions and
 #  limitations under the License.
 
-require 'couchbase/common_options'
-require 'couchbase/results'
-require 'couchbase/subdoc'
+require "couchbase/errors"
+require "couchbase/collection_options"
+require "couchbase/binary_collection"
 
 module Couchbase
   class Collection
@@ -26,8 +26,8 @@ module Couchbase
 
     # @param [Couchbase::Backend] backend
     # @param [String] bucket_name name of the bucket
-    # @param [String, :default] scope_name name of the scope
-    # @param [String, :default] collection_name name of the collection
+    # @param [String, :_default] scope_name name of the scope
+    # @param [String, :_default] collection_name name of the collection
     def initialize(backend, bucket_name, scope_name, collection_name)
       @backend = backend
       @bucket_name = bucket_name
@@ -43,16 +43,27 @@ module Couchbase
     end
 
     # Fetches the full document from the collection
-    # 
+    #
     # @param [String] id the document id which is used to uniquely identify it
     # @param [GetOptions] options request customization
-    # 
+    #
     # @return [GetResult]
     def get(id, options = GetOptions.new)
-      resp = @backend.get(bucket_name, "#{@scope_name}.#{@name}", id)
+      resp = if options.need_projected_get?
+               @backend.document_get_projected(bucket_name, "#{@scope_name}.#{@name}", id,
+                                               options.timeout,
+                                               options.with_expiry,
+                                               options.projections,
+                                               options.preserve_array_indexes)
+             else
+               @backend.document_get(bucket_name, "#{@scope_name}.#{@name}", id, options.timeout)
+             end
       GetResult.new do |res|
+        res.transcoder = options.transcoder
         res.cas = resp[:cas]
-        res.content = resp[:content]
+        res.flags = resp[:flags]
+        res.encoded = resp[:content]
+        res.expiry = resp[:expiry] if resp.key?(:expiry)
       end
     end
 
@@ -61,24 +72,40 @@ module Couchbase
     # @param [String] id the document id which is used to uniquely identify it.
     # @param [Integer] lock_time how long to lock the document (values over 30 seconds will be capped)
     # @param [GetAndLockOptions] options request customization
-    # 
+    #
     # @return [GetResult]
-    def get_and_lock(id, lock_time, options = GetAndLockOptions.new) end
+    def get_and_lock(id, lock_time, options = GetAndLockOptions.new)
+      resp = @backend.document_get_and_lock(bucket_name, "#{@scope_name}.#{@name}", id, options.timeout, lock_time)
+      GetResult.new do |res|
+        res.transcoder = options.transcoder
+        res.cas = resp[:cas]
+        res.flags = resp[:flags]
+        res.encoded = resp[:content]
+      end
+    end
 
-    # Fetches a full document and resets its expiration time to the expiration duration provided
+    # Fetches a full document and resets its expiration time to the duration provided
     #
     # @param [String] id the document id which is used to uniquely identify it.
-    # @param [Integer] expiration the new expiration time for the document
+    # @param [Integer] expiry the new expiration time for the document
     # @param [GetAndTouchOptions] options request customization
-    # 
+    #
     # @return [GetResult]
-    def get_and_touch(id, expiration, options = GetAndTouchOptions.new) end
+    def get_and_touch(id, expiry, options = GetAndTouchOptions.new)
+      resp = @backend.document_get_and_touch(bucket_name, "#{@scope_name}.#{@name}", id, options.timeout, expiry)
+      GetResult.new do |res|
+        res.transcoder = options.transcoder
+        res.cas = resp[:cas]
+        res.flags = resp[:flags]
+        res.encoded = resp[:content]
+      end
+    end
 
     # Reads from all available replicas and the active node and returns the results
-    # 
+    #
     # @param [String] id the document id which is used to uniquely identify it.
     # @param [GetAllReplicasOptions] options request customization
-    # 
+    #
     # @return [Array<GetReplicaResult>]
     def get_all_replicas(id, options = GetAllReplicasOptions.new) end
 
@@ -91,12 +118,19 @@ module Couchbase
     def get_any_replica(id, options = GetAnyReplicaOptions.new) end
 
     # Checks if the given document ID exists on the active partition.
-    # 
+    #
     # @param [String] id the document id which is used to uniquely identify it.
     # @param [ExistsOptions] options request customization
     #
     # @return [ExistsResult]
-    def exists(id, options = ExistsOptions.new) end
+    def exists(id, options = ExistsOptions.new)
+      resp = @backend.document_exists(bucket_name, "#{@scope_name}.#{@name}", id, options.timeout)
+      ExistsResult.new do |res|
+        res.status = resp[:status]
+        res.partition_id = resp[:partition_id]
+        res.cas = resp[:cas] if res.status != :not_found
+      end
+    end
 
     # Removes a document from the collection
     #
@@ -105,59 +139,97 @@ module Couchbase
     #
     # @return [MutationResult]
     def remove(id, options = RemoveOptions.new)
-      resp = @backend.remove(bucket_name, "#{@scope_name}.#{@name}", id)
+      resp = @backend.document_remove(bucket_name, "#{@scope_name}.#{@name}", id, options.timeout, {
+          durability_level: options.durability_level
+      })
       MutationResult.new do |res|
         res.cas = resp[:cas]
+        res.mutation_token = extract_mutation_token(resp)
       end
     end
 
     # Inserts a full document which does not exist yet
-    # 
+    #
     # @param [String] id the document id which is used to uniquely identify it.
     # @param [Object] content the document content to insert
     # @param [InsertOptions] options request customization
     #
     # @return [MutationResult]
-    def insert(id, content, options = InsertOptions.new) end
+    def insert(id, content, options = InsertOptions.new)
+      blob, flags = options.transcoder.encode(content)
+      resp = @backend.document_insert(bucket_name, "#{@scope_name}.#{@name}", id, options.timeout, blob, flags, {
+          durability_level: options.durability_level,
+          expiry: options.expiry,
+      })
+      MutationResult.new do |res|
+        res.cas = resp[:cas]
+        res.mutation_token = extract_mutation_token(resp)
+      end
+    end
 
     # Upserts (inserts or updates) a full document which might or might not exist yet
-    # 
+    #
     # @param [String] id the document id which is used to uniquely identify it.
     # @param [Object] content the document content to upsert
     # @param [UpsertOptions] options request customization
     #
     # @return [MutationResult]
     def upsert(id, content, options = UpsertOptions.new)
-      resp = @backend.upsert(bucket_name, "#{@scope_name}.#{@name}", id, JSON.dump(content))
+      blob, flags = options.transcoder.encode(content)
+      resp = @backend.document_upsert(bucket_name, "#{@scope_name}.#{@name}", id, options.timeout, blob, flags, {
+          durability_level: options.durability_level,
+          expiry: options.expiry,
+      })
       MutationResult.new do |res|
         res.cas = resp[:cas]
+        res.mutation_token = extract_mutation_token(resp)
       end
     end
 
     # Replaces a full document which already exists
-    # 
+    #
     # @param [String] id the document id which is used to uniquely identify it.
     # @param [Object] content the document content to upsert
     # @param [ReplaceOptions] options request customization
     #
     # @return [MutationResult]
-    def replace(id, content, options = ReplaceOptions.new) end
+    def replace(id, content, options = ReplaceOptions.new)
+      blob, flags = options.transcoder.encode(content)
+      resp = @backend.document_replace(bucket_name, "#{@scope_name}.#{@name}", id, options.timeout, blob, flags, {
+          durability_level: options.durability_level,
+          expiry: options.expiry,
+          cas: options.cas,
+      })
+      MutationResult.new do |res|
+        res.cas = resp[:cas]
+        res.mutation_token = extract_mutation_token(resp)
+      end
+    end
 
     # Update the expiration of the document with the given id
-    # 
+    #
     # @param [String] id the document id which is used to uniquely identify it.
-    # @param [Integer] expiration new expiration time for the document
+    # @param [Integer] expiry new expiration time for the document
     # @param [TouchOptions] options request customization
     #
     # @return [MutationResult]
-    def touch(id, expiration, options = TouchOptions.new) end
+    def touch(id, expiry, options = TouchOptions.new)
+      resp = @backend.document_touch(bucket_name, "#{@scope_name}.#{@name}", id, options.timeout, expiry)
+      MutationResult.new do |res|
+        res.cas = resp[:cas]
+      end
+    end
 
     # Unlocks a document if it has been locked previously
-    # 
+    #
     # @param [String] id the document id which is used to uniquely identify it.
     # @param [Integer] cas CAS value which is needed to unlock the document
-    # @param [TouchOptions] options request customization
-    def unlock(id, cas, options = UnlockOptions.new) end
+    # @param [UnlockOptions] options request customization
+    #
+    # @raise [Error::DocumentNotFound]
+    def unlock(id, cas, options = UnlockOptions.new)
+      @backend.document_unlock(bucket_name, "#{@scope_name}.#{@name}", id, options.timeout, cas)
+    end
 
     # Performs lookups to document fragments
     #
@@ -167,19 +239,28 @@ module Couchbase
     #
     # @return [LookupInResult]
     def lookup_in(id, specs, options = LookupInOptions.new)
-      resp = @backend.lookup_in(
-          bucket_name, "#{@scope_name}.#{@name}", id, options.access_deleted,
-          specs.map { |s| {opcode: s.type, xattr: s.xattr?, path: s.path} }
+      resp = @backend.document_lookup_in(
+          bucket_name, "#{@scope_name}.#{@name}", id, options.timeout, options.access_deleted,
+          specs.map { |s|
+            {
+                opcode: s.type,
+                xattr: s.xattr?,
+                path: s.path
+            }
+          }
       )
       LookupInResult.new do |res|
+        res.transcoder = options.transcoder
         res.cas = resp[:cas]
         res.encoded = resp[:fields].map do |field|
           SubDocumentField.new do |f|
             f.exists = field[:exists]
+            f.index = field[:index]
             f.path = field[:path]
             f.status = field[:status]
+            f.error = field[:error]
             f.value = field[:value]
-            f.type = field[:opcode]
+            f.type = field[:type]
           end
         end
       end
@@ -193,186 +274,58 @@ module Couchbase
     #
     # @return [MutateInResult]
     def mutate_in(id, specs, options = MutateInOptions.new)
-      resp = @backend.mutate_in(
-          bucket_name, "#{@scope_name}.#{@name}", id, options.access_deleted,
-          specs.map { |s| {opcode: s.type, path: s.path, param: s.param,
-                           xattr: s.xattr?, expand_macros: s.expand_macros?, create_parents: s.create_parents?} }
+      resp = @backend.document_mutate_in(
+          bucket_name, "#{@scope_name}.#{@name}", id, options.timeout,
+          specs.map { |s|
+            {
+                opcode: s.type,
+                path: s.path,
+                param: s.param,
+                xattr: s.xattr?,
+                expand_macros: s.expand_macros?,
+                create_path: s.create_path?
+            }
+          },
+          {
+              durability_level: options.durability_level,
+              store_semantics: options.store_semantics,
+              access_deleted: options.access_deleted,
+              cas: options.cas,
+              expiry: options.expiry,
+          }
       )
-      MutateInResult.new do |res|
+      res = MutateInResult.new do |res|
+        res.transcoder = options.transcoder
         res.cas = resp[:cas]
+        res.mutation_token = extract_mutation_token(resp)
         res.first_error_index = resp[:first_error_index]
         res.encoded = resp[:fields].map do |field|
           SubDocumentField.new do |f|
             f.exists = field[:exists]
             f.path = field[:path]
             f.status = field[:status]
+            f.error = field[:error]
             f.value = field[:value]
-            f.type = field[:opcode]
+            f.type = field[:type]
           end
         end
       end
-    end
-
-    class GetOptions < CommonOptions
-      # @return [Boolean] if the expiration should also fetched with get
-      attr_accessor :with_expiry
-
-      # @return [Proc] transcoder used for decoding
-      attr_accessor :transcoder
-
-      def initialize
-        yield self if block_given?
-      end
-
-      # Allows to specify a custom list paths to fetch from the document instead of the whole.
-      #
-      # Note that a maximum of 16 individual paths can be projected at a time due to a server limitation. If you need
-      # more than that, think about fetching less-generic paths or the full document straight away.
-      #
-      # @param [String, Array<String>] paths a path that should be loaded if present.
-      def project(*paths)
-        @projections ||= []
-        @projections |= paths # union with current projections
-      end
-    end
-
-    class GetAndLockOptions < CommonOptions
-      # @return [Proc] transcoder used for decoding
-      attr_accessor :transcoder
-
-      def initialize
-        yield self if block_given?
-      end
-    end
-
-    class GetAndTouchOptions < CommonOptions
-      # @return [Proc] transcoder used for decoding
-      attr_accessor :transcoder
-
-      def initialize
-        yield self if block_given?
-      end
-    end
-
-    class GetAllReplicasOptions < CommonOptions
-      # @return [Proc] transcoder used for decoding
-      attr_accessor :transcoder
-
-      def initialize
-        yield self if block_given?
-      end
-    end
-
-    class GetAnyReplicaOptions < CommonOptions
-      # @return [Proc] transcoder used for decoding
-      attr_accessor :transcoder
-
-      def initialize
-        yield self if block_given?
-      end
-    end
-
-    class ExistsOptions < CommonOptions
-      def initialize
-        yield self if block_given?
-      end
-    end
-
-    class RemoveOptions < CommonOptions
-      # @return [Integer] Specifies a CAS value that will be taken into account on the server side for optimistic concurrency
-      attr_accessor :cas
-
-      def initialize
-        yield self if block_given?
-      end
-    end
-
-    class InsertOptions < CommonOptions
-      # @return [Integer] expiration time to associate with the document
-      attr_accessor :expiration
-
-      # @return [Proc] transcoder used for encoding
-      attr_accessor :transcoder
-
-      def initialize
-        yield self if block_given?
-      end
-    end
-
-    class UpsertOptions < CommonOptions
-      # @return [Integer] expiration time to associate with the document
-      attr_accessor :expiration
-
-      # @return [Proc] transcoder used for encoding
-      attr_accessor :transcoder
-
-      def initialize
-        yield self if block_given?
-      end
-    end
-
-    class ReplaceOptions < CommonOptions
-      # @return [Integer] expiration time to associate with the document
-      attr_accessor :expiration
-
-      # @return [Proc] transcoder used for encoding
-      attr_accessor :transcoder
-
-      # @return [Integer] Specifies a CAS value that will be taken into account on the server side for optimistic concurrency
-      attr_accessor :cas
-
-      def initialize
-        yield self if block_given?
-      end
-    end
-
-    class TouchOptions < CommonOptions
-      def initialize
-        yield self if block_given?
-      end
-    end
-
-    class UnlockOptions < CommonOptions
-      def initialize
-        yield self if block_given?
-      end
-    end
-
-    class LookupInOptions < CommonOptions
-      # @return [Boolean] For internal use only: allows access to deleted documents that are in 'tombstone' form
-      attr_accessor :access_deleted
-
-      def initialize
-        yield self if block_given?
+      if res.success?
+        res
+      else
+        raise res.first_error
       end
     end
 
-    class MutateInOptions < CommonOptions
-      # @return [Integer] expiration time to associate with the document
-      attr_accessor :expiration
-
-      # Describes how the outer document store semantics on subdoc should act
-      #
-      # * +:replace+: replace the document, fail if it does not exist. This is the default
-      # * +:upsert+: replace the document or create if it does not exist
-      # * +:insert+: create the document, fail if it exists
-      #
-      # @return [:replace, :upsert, :insert]
-      attr_accessor :store_semantics
-
-      # @return [Integer] Specifies a CAS value that will be taken into account on the server side for optimistic concurrency
-      attr_accessor :cas
-
-      # @return [Boolean] For internal use only: allows access to deleted documents that are in 'tombstone' form
-      attr_accessor :access_deleted
-
-      # @return [Boolean] For internal use only: allows creating documents in 'tombstone' form
-      attr_accessor :create_as_deleted
+    private
 
-      def initialize
-        @store_semantics = :replace
-        yield self if block_given?
+    def extract_mutation_token(resp)
+      MutationToken.new do |token|
+        token.partition_id = resp[:mutation_token][:partition_id]
+        token.partition_uuid = resp[:mutation_token][:partition_uuid]
+        token.sequence_number = resp[:mutation_token][:sequence_number]
+        token.bucket_name = resp[:mutation_token][:bucket_name]
       end
     end
   end
-end
+end