couchbase 3.5.0-x86_64-darwin-20

data/lib/couchbase/protostellar/request_generator/query.rb

@@ -0,0 +1,133 @@
+#  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.
+
+# frozen_string_literal: true
+
+require "couchbase/protostellar/generated/query/v1/query_pb"
+require 'couchbase/protostellar/generated/kv/v1/kv_pb'
+require "couchbase/protostellar/request"
+
+require "google/protobuf/well_known_types"
+
+module Couchbase
+  module Protostellar
+    module RequestGenerator
+      class Query
+        SCAN_CONSISTENCY_MAP = {
+          :not_bounded => :SCAN_CONSISTENCY_NOT_BOUNDED,
+          :request_plus => :SCAN_CONSISTENCY_REQUEST_PLUS,
+        }.freeze
+
+        PROFILE_MODE_MAP = {
+          :off => :PROFILE_MODE_OFF,
+          :phases => :PROFILE_MODE_PHASES,
+          :timings => :PROFILE_MODE_TIMINGS,
+        }.freeze
+
+        attr_reader :bucket_name
+        attr_reader :scope_name
+
+        def initialize(bucket_name: nil, scope_name: nil)
+          @bucket_name = bucket_name
+          @scope_name = scope_name
+        end
+
+        def query_request(statement, options)
+          proto_opts = {}
+
+          bucket_name = @bucket_name
+          scope_name = @scope_name
+          unless options.scope_qualifier.nil?
+            if options.scope_qualifier.include? ":"
+              bucket_name, scope_name = options.scope_qualifier.split(":")[1].split(".")
+            else
+              bucket_name, scope_name = options.scope_qualifier.split(".")
+            end
+          end
+          proto_opts[:scope_name] = scope_name unless scope_name.nil?
+          proto_opts[:bucket_name] = bucket_name unless bucket_name.nil?
+
+          proto_opts[:read_only] = options.readonly unless options.readonly.nil?
+          proto_opts[:prepared] = !options.adhoc
+
+          tuning_opts = create_tuning_options(options)
+          proto_opts[:tuning_options] = tuning_opts unless tuning_opts.nil?
+
+          proto_opts[:client_context_id] = options.client_context_id unless options.client_context_id.nil?
+          unless options.instance_variable_get(:@scan_consistency).nil?
+            proto_opts[:scan_consistency] =
+              SCAN_CONSISTENCY_MAP[options.instance_variable_get(:@scan_consistency)]
+          end
+          proto_opts[:positional_parameters] = options.export_positional_parameters unless options.export_positional_parameters.nil?
+          proto_opts[:named_parameters] = options.export_named_parameters unless options.export_named_parameters.nil?
+          proto_opts[:flex_index] = options.flex_index unless options.flex_index.nil?
+          proto_opts[:preserve_expiry] = options.preserve_expiry unless options.preserve_expiry.nil?
+          proto_opts[:consistent_with] = get_consistent_with(options) unless options.mutation_state.nil?
+          proto_opts[:profile_mode] = PROFILE_MODE_MAP[options.profile]
+
+          proto_req = Generated::Query::V1::QueryRequest.new(
+            statement: statement,
+            **proto_opts
+          )
+
+          create_query_request(proto_req, :query, options, idempotent: options.readonly && true)
+        end
+
+        private
+
+        def create_query_request(proto_request, rpc, options, idempotent: false)
+          Request.new(
+            service: :query,
+            rpc: rpc,
+            proto_request: proto_request,
+            timeout: options.timeout,
+            idempotent: idempotent
+          )
+        end
+
+        def create_tuning_options(options)
+          tuning_opts = {}
+          tuning_opts[:max_parallelism] = options.max_parallelism unless options.max_parallelism.nil?
+          tuning_opts[:pipeline_batch] = options.pipeline_batch unless options.pipeline_batch.nil?
+          tuning_opts[:pipeline_cap] = options.pipeline_cap unless options.pipeline_cap.nil?
+          unless options.scan_wait.nil?
+            duration_millis = Utils::Time.extract_duration(options.scan_wait)
+            tuning_opts[:scan_wait] = Google::Protobuf::Duration.new(
+              seconds: duration_millis / 1000,
+              nanos: (duration_millis % 1000) * (10**6)
+            )
+          end
+          tuning_opts[:scan_cap] = options.scan_cap unless options.scan_cap.nil?
+          tuning_opts[:disable_metrics] = options.metrics.nil? || !options.metrics
+          if tuning_opts.empty?
+            nil
+          else
+            Generated::Query::V1::QueryRequest::TuningOptions.new(**tuning_opts)
+          end
+        end
+
+        def get_consistent_with(options)
+          options.mutation_state.tokens.map do |t|
+            Generated::KV::V1::MutationToken.new(
+              bucket_name: t.bucket_name,
+              vbucket_id: t.partition_id,
+              vbucket_uuid: t.partition_uuid,
+              seq_no: t.sequence_number
+            )
+          end
+        end
+      end
+    end
+  end
+end

data/lib/couchbase/protostellar/request_generator/search.rb

@@ -0,0 +1,387 @@
+#  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.
+
+# frozen_string_literal: true
+
+require "google/protobuf/well_known_types"
+
+require "couchbase/search_options"
+
+require "couchbase/protostellar/generated/search/v1/search_pb"
+require "couchbase/protostellar/request"
+
+module Couchbase
+  module Protostellar
+    module RequestGenerator
+      class Search
+        HIGHLIGHT_STYLE_MAP = {
+          :html => :HIGHLIGHT_STYLE_HTML,
+          :ansi => :HIGHLIGHT_STYLE_ANSI,
+          nil => :HIGHLIGHT_STYLE_DEFAULT,
+        }.freeze
+
+        MATCH_QUERY_OPERATOR_MAP = {
+          :or => :OPERATOR_OR,
+          :and => :OPERATOR_AND,
+        }.freeze
+
+        SCAN_CONSISTENCY_MAP = {
+          :not_bounded => :SCAN_CONSISTENCY_NOT_BOUNDED,
+        }.freeze
+
+        DEFAULT_LIMIT = 10
+        DEFAULT_SKIP = 0
+
+        def search_query_request(index_name, query, options)
+          proto_opts = {
+            scan_consistency: SCAN_CONSISTENCY_MAP[options.scan_consistency],
+            include_explanation: options.explain,
+            highlight_style: HIGHLIGHT_STYLE_MAP[options.highlight_style],
+            disable_scoring: options.disable_scoring,
+            include_locations: options.include_locations,
+          }
+
+          proto_opts[:highlight_fields] = options.highlight_fields unless options.highlight_fields.nil?
+          proto_opts[:fields] = options.fields unless options.fields.nil?
+          proto_opts[:sort] = get_sort(options) unless options.sort.nil?
+          proto_opts[:limit] = options.limit || DEFAULT_LIMIT
+          proto_opts[:skip] = options.skip || DEFAULT_SKIP
+          proto_opts[:collections] = options.collections unless options.collections.nil?
+
+          proto_req = Generated::Search::V1::SearchQueryRequest.new(
+            query: create_query(query),
+            index_name: index_name,
+            **proto_opts
+          )
+
+          # Set the search facets in the request
+          get_facets(options).each do |key, facet|
+            proto_req.facets[key] = facet
+          end
+
+          create_search_request(proto_req, :search_query, options)
+        end
+
+        private
+
+        def create_search_request(proto_request, rpc, options, idempotent: false)
+          Request.new(
+            service: :search,
+            rpc: rpc,
+            proto_request: proto_request,
+            timeout: options.timeout,
+            idempotent: idempotent
+          )
+        end
+
+        def create_query(query)
+          sq = Couchbase::Cluster::SearchQuery
+          res = Generated::Search::V1::Query.new
+
+          case query
+          when sq::BooleanFieldQuery
+            res.boolean_field_query = create_boolean_field_query(query)
+          when sq::BooleanQuery
+            res.boolean_query = create_boolean_query(query)
+          when sq::ConjunctionQuery
+            res.conjunction_query = create_conjunction_query(query)
+          when sq::DateRangeQuery
+            res.date_range_query = create_date_range_query(query)
+          when sq::DisjunctionQuery
+            res.disjunction_query = create_disjunction_query(query)
+          when sq::DocIdQuery
+            res.doc_id_query = create_doc_id_query(query)
+          when sq::GeoBoundingBoxQuery
+            res.geo_bounding_box_query = create_geo_bounding_box_query(query)
+          when sq::GeoDistanceQuery
+            res.geo_distance_query = create_geo_distance_query(query)
+          when sq::GeoPolygonQuery
+            res.geo_polygon_query = create_geo_polygon_query(query)
+          when sq::MatchAllQuery
+            res.match_all_query = create_match_all_query(query)
+          when sq::MatchNoneQuery
+            res.match_none_query = create_match_none_query(query)
+          when sq::MatchPhraseQuery
+            res.match_phrase_query = create_match_phrase_query(query)
+          when sq::MatchQuery
+            res.match_query = create_match_query(query)
+          when sq::NumericRangeQuery
+            res.numeric_range_query = create_numeric_range_query(query)
+          when sq::PhraseQuery
+            res.phrase_query = create_phrase_query(query)
+          when sq::PrefixQuery
+            res.prefix_query = create_prefix_query(query)
+          when sq::QueryStringQuery
+            res.query_string_query = create_query_string_query(query)
+          when sq::RegexpQuery
+            res.regexp_query = create_regexp_query(query)
+          when sq::TermQuery
+            res.term_query = create_term_query(query)
+          when sq::TermRangeQuery
+            res.term_range_query = create_term_range_query(query)
+          when sq::WildcardQuery
+            res.wildcard_query = create_wildcard_query(query)
+          else
+            raise Couchbase::Error::CouchbaseError, "Unexpected search query type #{query.class}"
+          end
+          res
+        end
+
+        def create_boolean_field_query(query)
+          query_attrs = query.to_h
+          query_attrs[:value] = query_attrs.delete(:bool)
+
+          Generated::Search::V1::BooleanFieldQuery.new(query_attrs)
+        end
+
+        def create_boolean_query(query)
+          query_attrs = {
+            boost: query.boost,
+            must: create_conjunction_query(query.instance_variable_get(:@must)),
+            must_not: create_disjunction_query(query.instance_variable_get(:@must_not)),
+            should: create_disjunction_query(query.instance_variable_get(:@should)),
+          }
+          Generated::Search::V1::BooleanQuery.new(query_attrs)
+        end
+
+        def create_conjunction_query(query)
+          query_attrs = {
+            boost: query.boost,
+            queries: query.instance_variable_get(:@queries).uniq.map(&:create_query),
+          }
+          Generated::Search::V1::ConjunctionQuery.new(query_attrs)
+        end
+
+        def create_date_range_query(query)
+          query_attrs = query.to_h
+          query_attrs[:start_date] = query_attrs.delete(:start)
+          query_attrs[:end_date] = query_attrs.delete(:end)
+
+          Generated::Search::V1::DateRangeQuery.new(query_attrs)
+        end
+
+        def create_disjunction_query(query)
+          query_attrs = {
+            boost: query.boost,
+            queries: query.instance_variable_get(:@queries).uniq.map(&:create_query),
+            minimum: query.min,
+          }
+          Generated::Search::V1::DisjunctionQuery.new(query_attrs)
+        end
+
+        def create_doc_id_query(query)
+          Generated::Search::V1::DocIdQuery.new(query.to_h)
+        end
+
+        def create_geo_bounding_box_query(query)
+          query_attrs = query.to_h
+          query_attrs[:top_left] = Generated::Search::V1::LatLng.new(
+            longitude: query_attrs[:top_left][0],
+            latitude: query_attrs[:top_left][1]
+          )
+          query_attrs[:bottom_right] = Generated::Search::V1::LatLng.new(
+            longitude: query_attrs[:bottom_right][0],
+            latitude: query_attrs[:bottom_right][1]
+          )
+          Generated::Search::V1::GeoBoundingBoxQuery.new(query_attrs)
+        end
+
+        def create_geo_distance_query(query)
+          query_attrs = query.to_h
+          longitude, latitude = query_attrs.delete(:location)
+          query_attrs[:center] = Generated::Search::V1::LatLng.new(
+            longitude: longitude,
+            latitude: latitude
+          )
+          Generated::Search::V1::GeoDistanceQuery.new(query_attrs)
+        end
+
+        def create_geo_polygon_query(query)
+          query_attrs = query.to_h
+          polygon_points = query_attrs.delete(:polygon_points)
+          query_attrs[:vertices] = polygon_points.map do |lon, lat|
+            Generated::Search::V1::LatLng.new(
+              longitude: lon,
+              latitude: lat
+            )
+          end
+          Generated::Search::V1::GeoPolygonQuery.new(query_attrs)
+        end
+
+        def create_match_all_query(_query)
+          Generated::Search::V1::MatchAllQuery.new
+        end
+
+        def create_match_none_query(_query)
+          Generated::Search::V1::MatchNoneQuery.new
+        end
+
+        def create_match_phrase_query(query)
+          query_attrs = query.to_h
+          query_attrs[:phrase] = query_attrs.delete(:match_phrase)
+
+          Generated::Search::V1::MatchPhraseQuery.new(query_attrs)
+        end
+
+        def create_match_query(query)
+          query_attrs = query.to_h
+          query_attrs[:value] = query_attrs.delete(:match)
+          query_attrs[:operator] = MATCH_QUERY_OPERATOR_MAP[query_attrs[:operator]] if query_attrs.include?(:operator)
+
+          Generated::Search::V1::MatchQuery.new(query_attrs)
+        end
+
+        def create_numeric_range_query(query)
+          Generated::Search::V1::NumericRangeQuery.new(query.to_h)
+        end
+
+        def create_phrase_query(query)
+          Generated::Search::V1::PhraseQuery.new(query.to_h)
+        end
+
+        def create_prefix_query(query)
+          Generated::Search::V1::PrefixQuery.new(query.to_h)
+        end
+
+        def create_query_string_query(query)
+          query_attrs = query.to_h
+          query_attrs[:query_string] = query_attrs.delete(:query)
+
+          Generated::Search::V1::QueryStringQuery.new(query_attrs)
+        end
+
+        def create_regexp_query(query)
+          Generated::Search::V1::RegexpQuery.new(query.to_h)
+        end
+
+        def create_term_query(query)
+          Generated::Search::V1::TermQuery.new(query.to_h)
+        end
+
+        def create_term_range_query(query)
+          Generated::Search::V1::TermRangeQuery.new(query.to_h)
+        end
+
+        def create_wildcard_query(query)
+          Generated::Search::V1::WildcardQuery.new(query.to_h)
+        end
+
+        def get_sort(options)
+          options.sort.map do |s|
+            case s
+            when Couchbase::Cluster::SearchSort::SearchSortField
+              # TODO: missing, type and mode could change to Enums
+              Generated::Search::V1::Sorting.new(
+                field_sorting: Generated::Search::V1::FieldSorting.new(
+                  field: s.field,
+                  descending: s.desc,
+                  missing: s.missing.to_s,
+                  mode: s.mode.to_s,
+                  type: s.type.to_s
+                )
+              )
+            when Couchbase::Cluster::SearchSort::SearchSortId
+              Generated::Search::V1::Sorting.new(
+                id_sorting: Generated::Search::V1::IdSorting.new(
+                  descending: s.desc
+                )
+              )
+            when Couchbase::Cluster::SearchSort::SearchSortScore
+              Generated::Search::V1::Sorting.new(
+                score_sorting: Generated::Search::V1::ScoreSorting.new(
+                  descending: s.desc
+                )
+              )
+            when Couchbase::Cluster::SearchSort::SearchSortGeoDistance
+              Generated::Search::V1::Sorting.new(
+                geo_distance_sorting: Generated::Search::V1::GeoDistanceSorting.new(
+                  field: s.field,
+                  descending: s.desc,
+                  center: Generated::Search::V1::LatLng.new(
+                    latitude: s.latitude,
+                    longitude: s.longitude
+                  ),
+                  unit: s.unit.to_s
+                )
+              )
+            when String
+              if s[0] == "-"
+                desc = true
+                field = s[1..]
+              else
+                desc = false
+                field = s
+              end
+              if field == "_score"
+                Generated::Search::V1::Sorting.new(
+                  score_sorting: Generated::Search::V1::ScoreSorting.new(
+                    descending: desc
+                  )
+                )
+              else
+                Generated::Search::V1::Sorting.new(
+                  # TODO: What to do with the rest of the FieldSorting attributes?
+                  core_sorting: Generated::Search::V1::FieldSorting.new(
+                    field: field,
+                    descending: desc
+                  )
+                )
+              end
+            else
+              raise Couchbase::Error::CouchbaseError, "Unrecognised search sort type"
+            end
+          end
+        end
+
+        def get_facets(options)
+          return {} if options.facets.nil?
+
+          options.facets.transform_values do |facet|
+            case facet
+            when Couchbase::Cluster::SearchFacet::SearchFacetTerm
+              Generated::Search::V1::Facet.new(
+                term_facet: Generated::Search::V1::TermFacet.new(
+                  field: facet.field,
+                  size: facet.size
+                )
+              )
+            when Couchbase::Cluster::SearchFacet::SearchFacetNumericRange
+              Generated::Search::V1::Facet.new(
+                numeric_range_facet: Generated::Search::V1::NumericRangeFacet.new(
+                  field: facet.field,
+                  size: facet.size,
+                  numeric_ranges: facet.instance_variable_get(:@ranges).map do |r|
+                    Generated::Search::V1::NumericRange(name: r[:name], min: r[:min], max: r[:max])
+                  end
+                )
+              )
+            when Couchbase::Cluster::SearchFacet::SearchFacetDateRange
+              Generated::Search::V1::Facet.new(
+                date_range_facet: Generated::Search::V1::DateRangeFacet.new(
+                  field: facet.field,
+                  size: facet.size,
+                  date_ranges: facet.instance_variable_get(:@ranges).map do |r|
+                    Generated::Search::V1::DateRange(name: r[:name], start: r[:start], end: r[:end])
+                  end
+                )
+              )
+            else
+              raise Couchbase::Error::CouchbaseError, "Unrecognised search facet type"
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/couchbase/protostellar/request_generator.rb

@@ -0,0 +1,26 @@
+#  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.
+
+# frozen_string_literal: true
+
+require_relative "request_generator/kv"
+require_relative "request_generator/query"
+
+module Couchbase
+  module Protostellar
+    # @api private
+    module RequestGenerator
+    end
+  end
+end

data/lib/couchbase/protostellar/response_converter/admin/bucket.rb

@@ -0,0 +1,55 @@
+#  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.
+
+# frozen_string_literal: true
+
+require "couchbase/management/bucket_manager"
+
+require_relative "../../request_generator/admin/bucket"
+
+module Couchbase
+  module Protostellar
+    module ResponseConverter
+      module Admin
+        class Bucket
+          BUCKET_TYPE_MAP = RequestGenerator::Admin::Bucket::BUCKET_TYPE_MAP.invert.freeze
+          EVICTION_MODE_MAP = RequestGenerator::Admin::Bucket::EVICTION_MODE_MAP.invert.freeze
+          COMPRESSION_MODE_MAP = RequestGenerator::Admin::Bucket::COMPRESSION_MODE_MAP.invert.freeze
+          STORAGE_BACKEND_MAP = RequestGenerator::Admin::Bucket::STORAGE_BACKEND_MAP.invert.freeze
+          CONFLICT_RESOLUTION_TYPE_MAP = RequestGenerator::Admin::Bucket::CONFLICT_RESOLUTION_TYPE_MAP.invert.freeze
+          DURABILITY_LEVEL_MAP = RequestGenerator::Admin::Bucket::DURABILITY_LEVEL_MAP.invert.freeze
+
+          def self.to_bucket_settings_array(resp)
+            resp.buckets.map do |r|
+              Couchbase::Management::BucketSettings.new do |b|
+                b.name = r.bucket_name
+                b.flush_enabled = r.flush_enabled
+                b.ram_quota_mb = r.ram_quota_mb
+                b.num_replicas = r.num_replicas
+                b.replica_indexes = r.replica_indexes
+                b.bucket_type = BUCKET_TYPE_MAP[r.bucket_type]
+                b.max_expiry = r.max_expiry_secs
+                b.eviction_policy = EVICTION_MODE_MAP[r.eviction_mode]
+                b.minimum_durability_level = DURABILITY_LEVEL_MAP[r.minimum_durability_level]
+                b.compression_mode = COMPRESSION_MODE_MAP[r.compression_mode]
+                b.conflict_resolution_type = CONFLICT_RESOLUTION_TYPE_MAP[r.conflict_resolution_type]
+                b.storage_backend = STORAGE_BACKEND_MAP[r.storage_backend]
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/couchbase/protostellar/response_converter/admin/collection.rb

@@ -0,0 +1,42 @@
+#  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.
+
+# frozen_string_literal: true
+
+require "couchbase/management/collection_manager"
+
+module Couchbase
+  module Protostellar
+    module ResponseConverter
+      module Admin
+        class Collection
+          def self.to_scope_spec_array(resp)
+            resp.scopes.map do |s|
+              Couchbase::Management::ScopeSpec.new do |scope_spec|
+                scope_spec.name = s.name
+                scope_spec.collections = s.collections.map do |c|
+                  Couchbase::Management::CollectionSpec.new do |coll_spec|
+                    coll_spec.name = c.name
+                    coll_spec.scope_name = s.name
+                    coll_spec.max_expiry = c.max_expiry_secs if c.has_max_expiry_secs?
+                  end
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end