couchbase 3.0.1 → 3.0.2

data/ext/test/test_ruby_trivial_crud.cxx

@@ -26,7 +26,7 @@ TEST_CASE("ruby: upsert document into default collection", "[ruby]")
 backend = Couchbase::Backend.new
 backend.open(CONNECTION_STRING, {username: USERNAME, password: PASSWORD}, {})
 backend.open_bucket(BUCKET, true)
-backend.document_upsert(BUCKET, "_default._default", "foo", 10_000, JSON.generate(foo: "bar"), 0, {})
+backend.document_upsert(BUCKET, "_default._default", "foo", JSON.generate(foo: "bar"), 0, {})
 backend.close
 )");
     if (error) {

data/lib/couchbase.rb

@@ -14,4 +14,5 @@
 
 require "couchbase/version"
 require "couchbase/libcouchbase"
+require "couchbase/logger"
 require "couchbase/cluster"

data/lib/couchbase/analytics_options.rb

@@ -12,80 +12,10 @@
 #  See the License for the specific language governing permissions and
 #  limitations under the License.
 
-require 'couchbase/json_transcoder'
+require "couchbase/json_transcoder"
 
 module Couchbase
   class Cluster
-    class AnalyticsOptions
-      # @return [Integer] Timeout in milliseconds
-      attr_accessor :timeout
-
-      # @return [String] Provides a custom client context ID for this query
-      attr_accessor :client_context_id
-
-      # @return [:not_bounded, :request_plus] specifies level of consistency for the query
-      attr_accessor :scan_consistency
-
-      # @return [Boolean] Allows explicitly marking a query as being readonly and not mutating any documents on the server side.
-      attr_accessor :readonly
-
-      # @return [Boolean] Allows to give certain requests higher priority than others
-      attr_accessor :priority
-
-      # @return [JsonTranscoder] transcoder to use on rows
-      attr_accessor :transcoder
-
-      # @api private
-      # @return [Hash<String => #to_json>]
-      attr_reader :raw_parameters
-
-      # @yieldparam [AnalyticsOptions] self
-      def initialize
-        @transcoder = JsonTranscoder.new
-        @raw_parameters = {}
-        @positional_parameters = nil
-        @named_parameters = nil
-        @scan_consistency = nil
-        yield self if block_given?
-      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
-
-      # @api private
-      # @return [Array<String>, nil]
-      def export_positional_parameters
-        @positional_parameters&.map { |p| JSON.dump(p) }
-      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
-
-      # 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)
-        @raw_parameters[key] = JSON.generate(value)
-      end
-
-      # @api private
-      # @return [Hash<String => String>, nil]
-      def export_named_parameters
-        @named_parameters&.each_with_object({}) { |(n, v), o| o[n.to_s] = JSON.dump(v) }
-      end
-    end
-
     class AnalyticsWarning
       # @return [Integer]
       attr_accessor :code

data/lib/couchbase/binary_collection.rb

@@ -12,6 +12,7 @@
 #  See the License for the specific language governing permissions and
 #  limitations under the License.
 
+require "couchbase/options"
 require "couchbase/binary_collection_options"
 
 module Couchbase
@@ -28,35 +29,59 @@ module Couchbase
     #
     # @param [String] id the document id which is used to uniquely identify it
     # @param [String] content the binary content to append to the document
-    # @param [AppendOptions] options custom options to customize the request
+    # @param [Options::Append] options custom options to customize the request
+    #
+    # @example Append "bar" to the content of the existing document
+    #   collection.upsert("mydoc", "foo")
+    #   collection.binary.append("mydoc", "bar", Options::Append(timeout: 3_000))
+    #   collection.get("mydoc", Options::Get(transcoder: nil)).content #=> "foobar"
     #
     # @return [Collection::MutationResult]
-    def append(id, content, options = AppendOptions.new) end
+    def append(id, content, options = Options::Append.new)
+      resp = @backend.document_append(@collection.bucket_name, "#{@collection.scope_name}.#{@collection.name}",
+                                      id, content, options.to_backend)
+      Collection::MutationResult.new do |res|
+        res.cas = resp[:cas]
+        res.mutation_token = @collection.send(:extract_mutation_token, resp)
+      end
+    end
 
     # Prepends binary content to the document
     #
     # @param [String] id the document id which is used to uniquely identify it
     # @param [String] content the binary content to prepend to the document
-    # @param [PrependOptions] options custom options to customize the request
+    # @param [Options::Prepend] options custom options to customize the request
+    #
+    # @example Prepend "bar" to the content of the existing document
+    #   collection.upsert("mydoc", "foo")
+    #   collection.binary.prepend("mydoc", "bar", Options::Prepend(timeout: 3_000))
+    #   collection.get("mydoc", Options::Get(transcoder: nil)).content #=> "barfoo"
     #
     # @return [Collection::MutationResult]
-    def prepend(id, content, options = PrependOptions.new) end
+    def prepend(id, content, options = Options::Prepend.new)
+      resp = @backend.document_prepend(@collection.bucket_name, "#{@collection.scope_name}.#{@collection.name}",
+                                       id, content, options.to_backend)
+      Collection::MutationResult.new do |res|
+        res.cas = resp[:cas]
+        res.mutation_token = @collection.send(:extract_mutation_token, resp)
+      end
+    end
 
     # Increments the counter document by one of the number defined in the options
     #
     # @param [String] id the document id which is used to uniquely identify it
-    # @param [IncrementOptions] options custom options to customize the request
+    # @param [Options::Increment] options custom options to customize the request
+    #
+    # @example Increment value by 10, and initialize to 0 if it does not exist
+    #   res = collection.binary.increment("raw_counter", Options::Increment(delta: 10, initial: 0))
+    #   res.content #=> 0
+    #   res = collection.binary.increment("raw_counter", Options::Increment(delta: 10, initial: 0))
+    #   res.content #=> 10
     #
     # @return [CounterResult]
-    def increment(id, options = IncrementOptions.new)
+    def increment(id, options = Options::Increment.new)
       resp = @backend.document_increment(@collection.bucket_name, "#{@collection.scope_name}.#{@collection.name}", id,
-                                         options.timeout,
-                                         {
-                                           delta: options.delta,
-                                           initial_value: options.initial,
-                                           expiry: options.expiry,
-                                           durability_level: options.durability_level,
-                                         })
+                                         options.to_backend)
       CounterResult.new do |res|
         res.cas = resp[:cas]
         res.content = resp[:content]
@@ -67,23 +92,36 @@ module Couchbase
     # Decrements the counter document by one of the number defined in the options
     #
     # @param [String] id the document id which is used to uniquely identify it
-    # @param [DecrementOptions] options custom options to customize the request
+    # @param [Options::Decrement] options custom options to customize the request
+    #
+    # @example Decrement value by 2, and initialize to 100 if it does not exist
+    #   res = collection.binary.decrement("raw_counter", Options::Decrement(delta: 2, initial: 100))
+    #   res.value #=> 100
+    #   res = collection.binary.decrement("raw_counter", Options::Decrement(delta: 2, initial: 100))
+    #   res.value #=> 98
     #
     # @return [CounterResult]
-    def decrement(id, options = DecrementOptions.new)
+    def decrement(id, options = Options::Decrement.new)
       resp = @backend.document_decrement(@collection.bucket_name, "#{@collection.scope_name}.#{@collection.name}", id,
-                                         options.timeout,
-                                         {
-                                           delta: options.delta,
-                                           initial_value: options.initial,
-                                           expiry: options.expiry,
-                                           durability_level: options.durability_level,
-                                         })
+                                         options.to_backend)
       CounterResult.new do |res|
         res.cas = resp[:cas]
         res.content = resp[:content]
         res.mutation_token = @collection.send(:extract_mutation_token, resp)
       end
     end
+
+    # @api private
+    # TODO: deprecate in 3.1
+    AppendOptions = ::Couchbase::Options::Append
+    # @api private
+    # TODO: deprecate in 3.1
+    PrependOptions = ::Couchbase::Options::Prepend
+    # @api private
+    # TODO: deprecate in 3.1
+    IncrementOptions = ::Couchbase::Options::Increment
+    # @api private
+    # TODO: deprecate in 3.1
+    DecrementOptions = ::Couchbase::Options::Decrement
   end
 end

data/lib/couchbase/binary_collection_options.rb

@@ -16,82 +16,6 @@ require "couchbase/collection_options"
 
 module Couchbase
   class BinaryCollection
-    class AppendOptions < CommonOptions
-      # @return [Integer] The default CAS used (0 means no CAS in this context)
-      attr_accessor :cas
-
-      # @yieldparam [AppendOptions] self
-      def initialize
-        super
-        yield self if block_given?
-      end
-    end
-
-    class PrependOptions < CommonOptions
-      # @return [Integer] The default CAS used (0 means no CAS in this context)
-      attr_accessor :cas
-
-      # @yieldparam [PrependOptions] self
-      def initialize
-        super
-        yield self if block_given?
-      end
-    end
-
-    class IncrementOptions < CommonOptions
-      # @return [Integer] the delta for the operation
-      attr_reader :delta
-
-      # @return [Integer] if present, holds the initial value
-      attr_accessor :initial
-
-      # @return [Integer] if set, holds the expiration for the operation
-      attr_accessor :expiry
-
-      # @return [:none, :majority, :majority_and_persist_to_active, :persist_to_majority] level of durability
-      attr_accessor :durability_level
-
-      # @yieldparam [IncrementOptions] self
-      def initialize
-        super
-        @delta = 1
-        yield self if block_given?
-      end
-
-      def delta=(value)
-        raise ArgumentError, "the delta cannot be less than 0" if delta.negative?
-
-        @delta = value
-      end
-    end
-
-    class DecrementOptions < CommonOptions
-      # @return [Integer] the delta for the operation
-      attr_reader :delta
-
-      # @return [Integer] if present, holds the initial value
-      attr_accessor :initial
-
-      # @return [Integer] if set, holds the expiration for the operation
-      attr_accessor :expiry
-
-      # @return [:none, :majority, :majority_and_persist_to_active, :persist_to_majority] level of durability
-      attr_accessor :durability_level
-
-      # @yieldparam [DecrementOptions] self
-      def initialize
-        super
-        @delta = 1
-        yield self if block_given?
-      end
-
-      def delta=(value)
-        raise ArgumentError, "the delta cannot be less than 0" if delta.negative?
-
-        @delta = value
-      end
-    end
-
     class CounterResult < ::Couchbase::Collection::MutationResult
       # @return [Integer] current value of the counter
       attr_accessor :content

data/lib/couchbase/bucket.rb

@@ -15,7 +15,9 @@
 require "couchbase/scope"
 require "couchbase/management/collection_manager"
 require "couchbase/management/view_index_manager"
+require "couchbase/options"
 require "couchbase/view_options"
+require "couchbase/diagnostics"
 
 module Couchbase
   class Bucket
@@ -67,29 +69,18 @@ module Couchbase
     #
     # @param [String] design_document_name name of the design document
     # @param [String] view_name name of the view to query
-    # @param [ViewOptions] options
+    # @param [Options::View] options
+    #
+    # @example Make sure the view engine catch up with all mutations and return keys starting from +["random_brewery:"]+
+    #   bucket.view_query("beer", "brewery_beers",
+    #                     Options::View(
+    #                       start_key: ["random_brewery:"],
+    #                       scan_consistency: :request_plus
+    #                     ))
     #
     # @return [ViewResult]
-    def view_query(design_document_name, view_name, options = ViewOptions.new)
-      resp = @backend.document_view(@name, design_document_name, view_name, options.namespace, {
-        timeout: options.timeout,
-        scan_consistency: options.scan_consistency,
-        skip: options.skip,
-        limit: options.limit,
-        start_key: (JSON.generate(options.start_key) unless options.start_key.nil?),
-        end_key: (JSON.generate(options.end_key) unless options.end_key.nil?),
-        start_key_doc_id: options.start_key_doc_id,
-        end_key_doc_id: options.end_key_doc_id,
-        inclusive_end: options.inclusive_end,
-        group: options.group,
-        group_level: options.group_level,
-        key: (JSON.generate(options.key) unless options.key.nil?),
-        keys: options.keys&.map { |key| JSON.generate(key) },
-        order: options.order,
-        reduce: options.reduce,
-        on_error: options.on_error,
-        debug: options.debug,
-      })
+    def view_query(design_document_name, view_name, options = Options::View.new)
+      resp = @backend.document_view(@name, design_document_name, view_name, options.namespace, options.to_backend)
       ViewResult.new do |res|
         res.meta_data = ViewMetaData.new do |meta|
           meta.total_rows = resp[:meta][:total_rows]
@@ -117,23 +108,36 @@ module Couchbase
 
     # Performs application-level ping requests against services in the couchbase cluster
     #
+    # @param [Options::Ping] options
+    #
     # @return [PingResult]
-    def ping(options = PingOptions.new) end
-
-    class PingOptions
-      # @return [String] Holds custom report id.
-      attr_accessor :report_id
-
-      # @return [Array<Symbol>] The service types to limit this diagnostics request
-      attr_accessor :service_types
-
-      # @return [Integer] the time in milliseconds allowed for the operation to complete
-      attr_accessor :timeout
-
-      def initialize
-        @service_types = [:kv, :query, :analytics, :search, :views, :management]
-        yield self if block_given?
+    def ping(options = Options::Ping.new)
+      resp = @backend.ping(@name, options.to_backend)
+      PingResult.new do |res|
+        res.version = resp[:version]
+        res.id = resp[:id]
+        res.sdk = resp[:sdk]
+        resp[:services].each do |type, svcs|
+          res.services[type] = svcs.map do |svc|
+            PingResult::ServiceInfo.new do |info|
+              info.id = svc[:id]
+              info.state = svc[:state]
+              info.latency = svc[:latency]
+              info.remote = svc[:remote]
+              info.local = svc[:local]
+              info.error = svc[:error]
+            end
+          end
+        end
       end
     end
+
+    # @api private
+    # TODO: deprecate in 3.1
+    PingOptions = ::Couchbase::Options::Ping
+
+    # @api private
+    # TODO: deprecate in 3.1
+    ViewOptions = ::Couchbase::Options::View
   end
 end

data/lib/couchbase/cluster.rb

@@ -21,9 +21,12 @@ require "couchbase/management/query_index_manager"
 require "couchbase/management/analytics_index_manager"
 require "couchbase/management/search_index_manager"
 
+require "couchbase/options"
+
 require "couchbase/search_options"
 require "couchbase/query_options"
 require "couchbase/analytics_options"
+require "couchbase/diagnostics"
 
 module Couchbase
   class Cluster
@@ -33,14 +36,32 @@ module Couchbase
     #
     # @overload connect(connection_string, options)
     #   @param [String] connection_string connection string used to locate the Couchbase Cluster
-    #   @param [ClusterOptions] options custom options when creating the cluster connection
+    #   @param [Options::Cluster] options custom options when creating the cluster connection
     #
     # @overload connect(connection_string, username, password, options)
     #   Shortcut for {PasswordAuthenticator}
     #   @param [String] connection_string connection string used to locate the Couchbase Cluster
     #   @param [String] username name of the user
     #   @param [String] password password of the user
-    #   @param [ClusterOptions, nil] options custom options when creating the cluster connection
+    #   @param [Options::Cluster, nil] options custom options when creating the cluster connection
+    #
+    # @example Explicitly create options object and initialize PasswordAuthenticator internally
+    #   options = Cluster::ClusterOptions.new
+    #   options.authenticate("Administrator", "password")
+    #   Cluster.connect("couchbase://localhost", options)
+    #
+    # @example Pass authenticator object to Options
+    #   Cluster.connect("couchbase://localhost",
+    #     Options::Cluster(authenticator: PasswordAuthenticator.new("Administrator", "password")))
+    #
+    # @example Shorter version, more useful for interactive sessions
+    #   Cluster.connect("couchbase://localhost", "Administrator", "password")
+    #
+    # @example Authentication with TLS client certificate (note +couchbases://+ schema)
+    #   Cluster.connect("couchbases://localhost?trust_certificate=/tmp/ca.pem",
+    #     Options::Cluster(authenticator: CertificateAuthenticator.new("/tmp/certificate.pem", "/tmp/private.key")))
+    #
+    # @see https://docs.couchbase.com/server/current/manage/manage-security/configure-client-certificates.html
     #
     # @return [Cluster]
     def self.connect(connection_string, *options)
@@ -59,30 +80,15 @@ module Couchbase
     # Performs a query against the query (N1QL) services
     #
     # @param [String] statement the N1QL query statement
-    # @param [QueryOptions] options the custom options for this query
+    # @param [Options::Query] options the custom options for this query
+    #
+    # @example Select first ten hotels from travel sample dataset
+    #   cluster.query("SELECT * FROM `travel-sample` WHERE type = $type LIMIT 10",
+    #                 Options::Query(named_parameters: {type: "hotel"}, metrics: true))
     #
     # @return [QueryResult]
-    def query(statement, options = QueryOptions.new)
-      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,
-        flex_index: options.flex_index,
-        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.export_positional_parameters,
-        named_parameters: options.export_named_parameters,
-        scope_qualifier: options.scope_qualifier,
-        raw_parameters: options.raw_parameters,
-        scan_consistency: options.scan_consistency,
-        mutation_state: options.mutation_state&.to_a,
-      })
+    def query(statement, options = Options::Query.new)
+      resp = @backend.document_query(statement, options.to_backend)
 
       QueryResult.new do |res|
         res.meta_data = QueryMetaData.new do |meta|
@@ -112,20 +118,15 @@ module Couchbase
     # Performs an analytics query
     #
     # @param [String] statement the N1QL query statement
-    # @param [AnalyticsOptions] options the custom options for this query
+    # @param [Options::Analytics] options the custom options for this query
+    #
+    # @example Select name of the given user
+    #   cluster.analytics_query("SELECT u.name AS uname FROM GleambookUsers u WHERE u.id = $user_id ",
+    #                           Options::Analytics(named_parameters: {user_id: 2}))
     #
     # @return [AnalyticsResult]
-    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,
-      })
+    def analytics_query(statement, options = Options::Analytics.new)
+      resp = @backend.document_analytics(statement, options.to_backend)
 
       AnalyticsResult.new do |res|
         res.transcoder = options.transcoder
@@ -156,24 +157,20 @@ module Couchbase
     #
     # @param [String] index_name the name of the search index
     # @param [SearchQuery] query the query tree
-    # @param [SearchOptions] options the query tree
+    # @param [Options::Search] options the query tree
+    #
+    # @example Return first 10 results of "hop beer" query and request highlighting
+    #   cluster.search_query("beer_index", Cluster::SearchQuery.match_phrase("hop beer"),
+    #                        Options::Search(
+    #                          limit: 10,
+    #                          fields: %w[name],
+    #                          highlight_style: :html,
+    #                          highlight_fields: %w[name description]
+    #                        ))
     #
     # @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,
-        disable_scoring: options.disable_scoring,
-        highlight_style: options.highlight_style,
-        highlight_fields: options.highlight_fields,
-        fields: options.fields,
-        sort: options.sort&.map { |v| JSON.generate(v) },
-        facets: options.facets&.map { |(k, v)| [k, JSON.generate(v)] },
-        scan_consistency: options.scan_consistency,
-        mutation_state: options.mutation_state&.to_a,
-      })
+    def search_query(index_name, query, options = Options::Search.new)
+      resp = @backend.document_search(index_name, JSON.generate(query), options.to_backend)
 
       SearchResult.new do |res|
         res.meta_data = SearchMetaData.new do |meta|
@@ -293,10 +290,11 @@ module Couchbase
     #
     # It does not proactively perform any I/O against the network
     #
+    # @param [Options::Diagnostics] options
+    #
     # @return [DiagnosticsResult]
-    def diagnostics(options = DiagnosticsOptions.new)
+    def diagnostics(options = Options::Diagnostics.new)
       resp = @backend.diagnostics(options.report_id)
-      pp resp
       DiagnosticsResult.new do |res|
         res.version = resp[:version]
         res.id = resp[:id]
@@ -309,113 +307,37 @@ module Couchbase
               info.last_activity_us = svc[:last_activity_us]
               info.remote = svc[:remote]
               info.local = svc[:local]
+              info.details = svc[:details]
             end
           end
         end
       end
     end
 
-    class ClusterOptions
-      attr_accessor :authenticator
-
-      # @yieldparam [ClusterOptions] self
-      def initialize
-        yield self if block_given?
-      end
-
-      def authenticate(username, password)
-        @authenticator = PasswordAuthenticator.new(username, password)
-        self
-      end
-    end
-
-    class DiagnosticsOptions
-      # @return [String] Holds custom report id.
-      attr_accessor :report_id
-
-      # @yieldparam [DiagnosticsOptions] self
-      def initialize
-        yield self if block_given?
-      end
-    end
-
-    class DiagnosticsResult
-      class ServiceInfo
-        # @return [String] endpoint unique identifier
-        attr_accessor :id
-
-        # Possible states are:
-        #
-        # :disconnected:: the endpoint is not reachable
-        # :connecting:: currently connecting (includes auth, handshake, etc.)
-        # :connected:: connected and ready
-        # :disconnecting:: disconnecting (after being connected)
-        #
-        # @return [Symbol] state of the endpoint
-        attr_accessor :state
-
-        # @return [Integer] how long ago the endpoint was active (in microseconds)
-        attr_accessor :last_activity_us
-
-        # @return [String] remote address of the connection
-        attr_accessor :remote
-
-        # @return [String] local address of the connection
-        attr_accessor :local
-
-        # @yieldparam [ServiceInfo] self
-        def initialize
-          yield self if block_given?
-        end
-
-        def to_json(*args)
-          data = {
-            id: @id,
-            state: @state,
-            remote: @remote,
-            local: @local,
-          }
-          data[:last_activity_us] = @last_activity_us if defined? @last_activity_us
-          data.to_json(*args)
+    # Performs application-level ping requests against services in the couchbase cluster
+    #
+    # @param [Options::Ping] options
+    #
+    # @return [PingResult]
+    def ping(options = Options::Ping.new)
+      resp = @backend.ping(nil, options.to_backend)
+      PingResult.new do |res|
+        res.version = resp[:version]
+        res.id = resp[:id]
+        res.sdk = resp[:sdk]
+        resp[:services].each do |type, svcs|
+          res.services[type] = svcs.map do |svc|
+            PingResult::ServiceInfo.new do |info|
+              info.id = svc[:id]
+              info.state = svc[:state]
+              info.latency = svc[:latency]
+              info.remote = svc[:remote]
+              info.local = svc[:local]
+              info.error = svc[:error]
+            end
+          end
         end
       end
-
-      # @return [String] report id
-      attr_accessor :id
-
-      # @return [String] SDK identifier
-      attr_accessor :sdk
-
-      # Returns information about currently service endpoints, that known to the library at the moment.
-      #
-      # :kv:: Key/Value data service
-      # :query:: N1QL query service
-      # :analytics:: Analtyics service
-      # :search:: Full text search service
-      # :views:: Views service
-      # :mgmt:: Management service
-      #
-      # @return [Hash<Symbol, ServiceInfo>] map service types to info
-      attr_accessor :services
-
-      # @yieldparam [DiagnosticsResult] self
-      def initialize
-        @services = Hash.new
-        yield self if block_given?
-      end
-
-      # @api private
-      # @return [Integer] version
-      attr_accessor :version
-
-      def to_json(*args)
-        {
-          version: @version,
-          id: @id,
-          sdk: @sdk,
-          services: @services,
-        }.to_json(*args)
-      end
     end
 
     private
@@ -424,14 +346,14 @@ module Couchbase
     #
     # @overload new(connection_string, options)
     #   @param [String] connection_string connection string used to locate the Couchbase Cluster
-    #   @param [ClusterOptions] options custom options when creating the cluster connection
+    #   @param [Options::Cluster] options custom options when creating the cluster connection
     #
     # @overload new(connection_string, username, password, options)
     #   Shortcut for {PasswordAuthenticator}
     #   @param [String] connection_string connection string used to locate the Couchbase Cluster
     #   @param [String] username name of the user
     #   @param [String] password password of the user
-    #   @param [ClusterOptions, nil] options custom options when creating the cluster connection
+    #   @param [Options::Cluster, nil] options custom options when creating the cluster connection
     def initialize(connection_string, *args)
       credentials = {}
 
@@ -442,7 +364,7 @@ module Couchbase
         credentials[:password] = args.shift
         raise ArgumentError, "missing username" unless credentials[:username]
         raise ArgumentError, "missing password" unless credentials[:password]
-      when ClusterOptions
+      when Options::Cluster
         authenticator = options&.authenticator
         case authenticator
         when PasswordAuthenticator
@@ -469,5 +391,16 @@ module Couchbase
       @backend = Backend.new
       @backend.open(connection_string, credentials, {})
     end
+
+    # @api private
+    ClusterOptions = ::Couchbase::Options::Cluster
+    # @api private
+    DiagnosticsOptions = ::Couchbase::Options::Diagnostics
+    # @api private
+    AnalyticsOptions = ::Couchbase::Options::Analytics
+    # @api private
+    QueryOptions = ::Couchbase::Options::Query
+    # @api private
+    SearchOptions = ::Couchbase::Options::Search
   end
 end