manticore-client 1.0.0

data/lib/manticore/client/models/update_response.rb

@@ -0,0 +1,252 @@
+=begin
+#Manticore Search Client
+
+#Сlient for Manticore Search. 
+
+The version of the OpenAPI document: 5.0.0
+Contact: info@manticoresearch.com
+Generated by: https://openapi-generator.tech
+Generator version: 7.13.0
+
+=end
+
+require 'date'
+require 'time'
+
+module Manticore::Client
+  # Success response returned after updating one or more documents
+  class UpdateResponse
+    # Name of the document table
+    attr_accessor :table
+
+    # Number of documents updated
+    attr_accessor :updated
+
+    # Document ID
+    attr_accessor :id
+
+    # Result of the update operation, typically 'updated'
+    attr_accessor :result
+
+    # Attribute mapping from ruby-style variable name to JSON key.
+    def self.attribute_map
+      {
+        :'table' => :'table',
+        :'updated' => :'updated',
+        :'id' => :'id',
+        :'result' => :'result'
+      }
+    end
+
+    # Returns attribute mapping this model knows about
+    def self.acceptable_attribute_map
+      attribute_map
+    end
+
+    # Returns all the JSON keys this model knows about
+    def self.acceptable_attributes
+      acceptable_attribute_map.values
+    end
+
+    # Attribute type mapping.
+    def self.openapi_types
+      {
+        :'table' => :'String',
+        :'updated' => :'Integer',
+        :'id' => :'Integer',
+        :'result' => :'String'
+      }
+    end
+
+    # List of attributes with nullable: true
+    def self.openapi_nullable
+      Set.new([
+      ])
+    end
+
+    # Initializes the object
+    # @param [Hash] attributes Model attributes in the form of hash
+    def initialize(attributes = {})
+      if (!attributes.is_a?(Hash))
+        fail ArgumentError, "The input argument (attributes) must be a hash in `Manticore::Client::UpdateResponse` initialize method"
+      end
+
+      # check to see if the attribute exists and convert string to symbol for hash key
+      acceptable_attribute_map = self.class.acceptable_attribute_map
+      attributes = attributes.each_with_object({}) { |(k, v), h|
+        if (!acceptable_attribute_map.key?(k.to_sym))
+          fail ArgumentError, "`#{k}` is not a valid attribute in `Manticore::Client::UpdateResponse`. Please check the name to make sure it's valid. List of attributes: " + acceptable_attribute_map.keys.inspect
+        end
+        h[k.to_sym] = v
+      }
+
+      if attributes.key?(:'table')
+        self.table = attributes[:'table']
+      end
+
+      if attributes.key?(:'updated')
+        self.updated = attributes[:'updated']
+      end
+
+      if attributes.key?(:'id')
+        self.id = attributes[:'id']
+      end
+
+      if attributes.key?(:'result')
+        self.result = attributes[:'result']
+      end
+    end
+
+    # Show invalid properties with the reasons. Usually used together with valid?
+    # @return Array for valid properties with the reasons
+    def list_invalid_properties
+      warn '[DEPRECATED] the `list_invalid_properties` method is obsolete'
+      invalid_properties = Array.new
+      invalid_properties
+    end
+
+    # Check to see if the all the properties in the model are valid
+    # @return true if the model is valid
+    def valid?
+      warn '[DEPRECATED] the `valid?` method is obsolete'
+      true
+    end
+
+    # Checks equality by comparing each attribute.
+    # @param [Object] Object to be compared
+    def ==(o)
+      return true if self.equal?(o)
+      self.class == o.class &&
+          table == o.table &&
+          updated == o.updated &&
+          id == o.id &&
+          result == o.result
+    end
+
+    # @see the `==` method
+    # @param [Object] Object to be compared
+    def eql?(o)
+      self == o
+    end
+
+    # Calculates hash code according to all attributes.
+    # @return [Integer] Hash code
+    def hash
+      [table, updated, id, result].hash
+    end
+
+    # Builds the object from hash
+    # @param [Hash] attributes Model attributes in the form of hash
+    # @return [Object] Returns the model itself
+    def self.build_from_hash(attributes)
+      return nil unless attributes.is_a?(Hash)
+      attributes = attributes.transform_keys(&:to_sym)
+      transformed_hash = {}
+      openapi_types.each_pair do |key, type|
+        if attributes.key?(attribute_map[key]) && attributes[attribute_map[key]].nil?
+          transformed_hash["#{key}"] = nil
+        elsif type =~ /\AArray<(.*)>/i
+          # check to ensure the input is an array given that the attribute
+          # is documented as an array but the input is not
+          if attributes[attribute_map[key]].is_a?(Array)
+            transformed_hash["#{key}"] = attributes[attribute_map[key]].map { |v| _deserialize($1, v) }
+          end
+        elsif !attributes[attribute_map[key]].nil?
+          transformed_hash["#{key}"] = _deserialize(type, attributes[attribute_map[key]])
+        end
+      end
+      new(transformed_hash)
+    end
+
+    # Deserializes the data based on type
+    # @param string type Data type
+    # @param string value Value to be deserialized
+    # @return [Object] Deserialized data
+    def self._deserialize(type, value)
+      case type.to_sym
+      when :Time
+        Time.parse(value)
+      when :Date
+        Date.parse(value)
+      when :String
+        value.to_s
+      when :Integer
+        value.to_i
+      when :Float
+        value.to_f
+      when :Boolean
+        if value.to_s =~ /\A(true|t|yes|y|1)\z/i
+          true
+        else
+          false
+        end
+      when :Object
+        # generic object (usually a Hash), return directly
+        value
+      when /\AArray<(?<inner_type>.+)>\z/
+        inner_type = Regexp.last_match[:inner_type]
+        value.map { |v| _deserialize(inner_type, v) }
+      when /\AHash<(?<k_type>.+?), (?<v_type>.+)>\z/
+        k_type = Regexp.last_match[:k_type]
+        v_type = Regexp.last_match[:v_type]
+        {}.tap do |hash|
+          value.each do |k, v|
+            hash[_deserialize(k_type, k)] = _deserialize(v_type, v)
+          end
+        end
+      else # model
+        # models (e.g. Pet) or oneOf
+        klass = Manticore::Client.const_get(type)
+        klass.respond_to?(:openapi_any_of) || klass.respond_to?(:openapi_one_of) ? klass.build(value) : klass.build_from_hash(value)
+      end
+    end
+
+    # Returns the string representation of the object
+    # @return [String] String presentation of the object
+    def to_s
+      to_hash.to_s
+    end
+
+    # to_body is an alias to to_hash (backward compatibility)
+    # @return [Hash] Returns the object in the form of hash
+    def to_body
+      to_hash
+    end
+
+    # Returns the object in the form of hash
+    # @return [Hash] Returns the object in the form of hash
+    def to_hash
+      hash = {}
+      self.class.attribute_map.each_pair do |attr, param|
+        value = self.send(attr)
+        if value.nil?
+          is_nullable = self.class.openapi_nullable.include?(attr)
+          next if !is_nullable || (is_nullable && !instance_variable_defined?(:"@#{attr}"))
+        end
+
+        hash[param] = _to_hash(value)
+      end
+      hash
+    end
+
+    # Outputs non-array value in the form of hash
+    # For object, use to_hash. Otherwise, just return the value
+    # @param [Object] value Any valid value
+    # @return [Hash] Returns the value in the form of hash
+    def _to_hash(value)
+      if value.is_a?(Array)
+        value.compact.map { |v| _to_hash(v) }
+      elsif value.is_a?(Hash)
+        {}.tap do |hash|
+          value.each { |k, v| hash[k] = _to_hash(v) }
+        end
+      elsif value.respond_to? :to_hash
+        value.to_hash
+      else
+        value
+      end
+    end
+
+  end
+
+end

data/lib/manticore/client/version.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module Manticore
+  module Client
+    VERSION = "1.0.0"
+  end
+end

data/lib/manticore/client.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+require "zeitwerk"
+
+loader = Zeitwerk::Loader.for_gem
+loader.push_dir(__dir__, namespace: Manticore)
+loader.push_dir("#{__dir__}/client/api", namespace: Manticore::Client)
+loader.push_dir("#{__dir__}/client/models", namespace: Manticore::Client)
+loader.setup
+
+module Manticore
+  # The Manticore Search client for Ruby.
+  module Client
+    class << self
+      # Customize default settings for the SDK using block.
+      #   Manticore::Client.configure do |config|
+      #     config.username = "xxx"
+      #     config.password = "xxx"
+      #   end
+      # If no block given, return the default Configuration object.
+      def configure
+        if block_given?
+          yield(Configuration.default)
+        else
+          Configuration.default
+        end
+      end
+    end
+  end
+end
+
+loader.eager_load

data/lib/manticore-client.rb

@@ -0,0 +1,3 @@
+# frozen_string_literal: true
+
+require_relative "manticore/client"

data/manticore-client.gemspec

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+$LOAD_PATH.unshift File.expand_path("lib", __dir__)
+require "manticore/client/version"
+
+Gem::Specification.new do |spec|
+  spec.name = "manticore-client"
+  spec.version = Manticore::Client::VERSION
+  spec.platform = Gem::Platform::RUBY
+  spec.authors = ["OpenAPI-Generator"]
+  spec.email = ["subbota@gmail.com"]
+  spec.homepage = "https://github.com/numbata/manticore-client"
+  spec.summary = "Autogenerated Manticore Search client"
+  spec.description = "Сlient for Manticore Search. "
+  spec.license = "MIT"
+  spec.required_ruby_version = ">= 2.7"
+  spec.metadata = {
+    "bug_tracker_uri" => "#{spec.homepage}/issues",
+    "changelog_uri" => "#{spec.homepage}/blob/v#{spec.version}/CHANGELOG.md",
+    "homepage_uri" => spec.homepage,
+    "source_code_uri" => spec.homepage,
+    "rubygems_mfa_required" => "true"
+  }
+
+  spec.add_dependency "faraday", ">= 1.0.1", "< 3.0"
+  spec.add_dependency "faraday-multipart"
+  spec.add_dependency "marcel"
+  spec.add_dependency "zeitwerk"
+
+  spec.files = `git ls-files`.split("\n")
+
+  spec.executables = []
+  spec.require_paths = ["lib"]
+end

data/spec/api/index_api_spec.rb

@@ -0,0 +1,179 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+RSpec.describe "IndexApi" do
+  subject(:index_api) { Manticore::Client::IndexApi.new }
+
+  let(:table_name) { "#{TABLE_PREFIX}movies" }
+
+  before do
+    ManticoreSqlHelper.query("CREATE TABLE #{table_name} (title TEXT, rating FLOAT)")
+    ManticoreSqlHelper.query(<<~SQL)
+      INSERT INTO #{table_name} (id, title, rating) VALUES
+        (1, 'Scary movie', 9.5),
+        (2, 'Horror movie', 2.1)
+    SQL
+  end
+
+  after do
+    ManticoreSqlHelper.drop_table(table_name)
+  end
+
+  # Sends multiple operations like inserts, updates, replaces, or deletes.
+  describe "#bulk" do
+    it "creates batch of documents" do
+      request_body = <<~NDJSON
+        { "insert": { "index": "#{table_name}", "id": 3, "doc": { "title": "New movie", "rating": 8.5 } } }
+        { "delete": { "index": "#{table_name}", "id": 2 } }
+      NDJSON
+
+      result = index_api.bulk(request_body)
+
+      expect(result.items[0][:bulk]).to include(
+        table: table_name,
+        created: 1,
+        deleted: 1,
+        result: "updated"
+      )
+      expect(table_name).to have_docs(
+        { id: 1, title: "Scary movie", rating: 9.5 },
+        { id: 3, title: "New movie", rating: 8.5 }
+      )
+      expect(table_name).not_to have_docs(
+        { id: 2, title: "Horror movie", rating: 2.1 }
+      )
+    end
+  end
+
+  # Delete one or several documents.
+  describe "#delete" do
+    it "removes one doc from table" do
+      request = Manticore::Client::DeleteDocumentRequest.new(
+        table: table_name,
+        id: 2
+      )
+
+      result = index_api.delete(request)
+
+      expect(result).to be_a(Manticore::Client::DeleteResponse)
+      expect(result).to have_attributes(
+        table: table_name,
+        result: "deleted"
+      )
+      expect(table_name).to have_docs(
+        { id: 1, title: "Scary movie", rating: 9.5 }
+      )
+      expect(table_name).not_to have_docs(
+        { id: 2, title: "Horror movie", rating: 2.1 }
+      )
+    end
+
+    it "removes several docs from table" do
+      request = Manticore::Client::DeleteDocumentRequest.new(
+        table: table_name,
+        id: [1, 2]
+      )
+
+      result = index_api.delete(request)
+
+      expect(result).to be_a(Manticore::Client::DeleteResponse)
+      expect(result).to have_attributes(
+        table: table_name,
+        result: "deleted"
+      )
+      expect(table_name).not_to have_docs(
+        { id: 1, title: "Scary movie", rating: 9.5 },
+        { id: 2, title: "Horror movie", rating: 2.1 }
+      )
+    end
+  end
+
+  # Insert a new document in a table.
+  describe "#insert" do
+    it "inserts a new document" do
+      request = Manticore::Client::InsertDocumentRequest.new(
+        table: table_name,
+        id: 3,
+        doc: { title: "Brand new movie", rating: 7.7 }
+      )
+
+      result = index_api.insert(request)
+
+      expect(result).to be_a(Manticore::Client::SuccessResponse)
+      expect(result).to have_attributes(
+        table: table_name,
+        id: 3,
+        created: true,
+        result: "created"
+      )
+      expect(table_name).to have_docs(
+        { id: 3, title: "Brand new movie", rating: 7.7 }
+      )
+    end
+  end
+
+  # Partially replaces a document in a table.
+  describe "#partial_replace" do
+    it "partially updates a document" do
+      request = Manticore::Client::ReplaceDocumentRequest.new(
+        doc: { rating: 8.8 }
+      )
+      id = 1
+
+      result = index_api.partial_replace(table_name, id, request)
+
+      expect(result).to be_a(Manticore::Client::UpdateResponse)
+      expect(result).to have_attributes(updated: 1)
+      expect(table_name).to have_docs(
+        { id: 1, title: "Scary movie", rating: 8.8 }
+      )
+    end
+  end
+
+  # Replace a document in a table (full replace)
+  describe "#replace" do
+    it "fully replaces a document" do
+      request = Manticore::Client::InsertDocumentRequest.new(
+        table: table_name,
+        id: 1,
+        doc: { title: "Completely new", rating: 5.5 }
+      )
+
+      result = index_api.replace(request)
+
+      expect(result).to be_a(Manticore::Client::SuccessResponse)
+      expect(result).to have_attributes(
+        table: table_name,
+        id: 1,
+        created: false,
+        result: "updated"
+      )
+      expect(table_name).to have_docs(
+        { id: 1, title: "Completely new", rating: 5.5 }
+      )
+    end
+  end
+
+  # Update a document in a table (by id).
+  describe "#update" do
+    it "updates a document by id" do
+      request = Manticore::Client::UpdateDocumentRequest.new(
+        table: table_name,
+        id: 1,
+        doc: { rating: 4.2 }
+      )
+
+      result = index_api.update(request)
+
+      expect(result).to be_a(Manticore::Client::UpdateResponse)
+      expect(result).to have_attributes(
+        table: table_name,
+        result: "updated"
+      )
+      expect(table_name).to have_docs(
+        { id: 1, title: "Scary movie", rating: 4.2 }
+      )
+    end
+  end
+end

data/spec/api/search_api_spec.rb

@@ -0,0 +1,94 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+RSpec.describe "SearchApi" do
+  let(:table_name) { "#{TABLE_PREFIX}movies" }
+  let(:percolate_table_name) { "#{TABLE_PREFIX}pq" }
+  let(:api_instance) { Manticore::Client::SearchApi.new }
+  let(:index_api) { Manticore::Client::IndexApi.new }
+
+  before do
+    # Create a simple table for testing
+    ManticoreSqlHelper.query(<<~SQL)
+      CREATE TABLE #{table_name}(title text, rating float) min_infix_len = '3'
+    SQL
+    # Insert test data
+    ManticoreSqlHelper.query(<<~SQL)
+      INSERT INTO #{table_name} (id, title, rating) VALUES
+        (1, 'Hello world', 9.5), (2, 'Helium', 7.1), (3, 'Other', 5.0)
+    SQL
+  end
+
+  after do
+    ManticoreSqlHelper.drop_table(table_name)
+  end
+
+  describe "#autocomplete" do
+    it "returns suggestions for prefix" do
+      request = Manticore::Client::AutocompleteRequest.new(table: table_name, query: "Hel")
+      result = api_instance.autocomplete(request)
+      suggestions = result.first[:data].map { |row| row[:query] }
+      expect(suggestions).to include("hello", "helium")
+    end
+  end
+
+  describe "#search" do
+    it "returns matching documents" do
+      request = Manticore::Client::SearchRequest.new(table: table_name, query: { match: { title: "Hello" } })
+      result = api_instance.search(request)
+      expect(result.hits.total).to eq(1)
+      expect(result.hits.hits.first._source[:title]).to eq("Hello world")
+    end
+  end
+
+  describe "#percolate" do
+    before do
+      # Create a percolate table with explicit schema following the docs
+      ManticoreSqlHelper.query(<<~SQL)
+        CREATE TABLE #{percolate_table_name}(title text, rating float) type='pq'
+      SQL
+
+      # Insert queries in the format shown in the official docs
+      ManticoreSqlHelper.query(<<~SQL)
+        INSERT INTO #{percolate_table_name}(id, query, filters) VALUES
+          (1, '@title hello', ''),
+          (2, '@title world', ''),
+          (3, '@title high', 'rating > 8.0')
+      SQL
+    end
+
+    after do
+      ManticoreSqlHelper.drop_table(percolate_table_name)
+    end
+
+    it "matches document against stored queries" do
+      # Create a document to test against the stored queries
+      # Include 'high' in the title to match query 3 and rating > 8.0 to match the filter
+      document = { title: "Hello world high", rating: 9.0 }
+
+      # Create a percolate request following the docs
+      request = Manticore::Client::PercolateRequest.new(
+        query: {
+          percolate: {
+            document: document
+          }
+        }
+      )
+
+      # Perform the percolate search
+      result = api_instance.percolate(percolate_table_name, request)
+
+      # Verify the results
+      expect(result.hits.total).to be >= 2 # Should match queries 1, 2, and 3
+
+      # Extract the matched query IDs
+      query_ids = result.hits.hits.map { |hit| hit._id.to_i }
+
+      # Verify specific matches
+      expect(query_ids).to include(1)  # '@title hello' query
+      expect(query_ids).to include(2)  # '@title world' query
+      expect(query_ids).to include(3)  # '@title high' with 'rating > 8.0' filter
+    end
+  end
+end

data/spec/api/utils_api_spec.rb

@@ -0,0 +1,100 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+RSpec.describe "UtilsApi" do
+  let(:table_name) { "#{TABLE_PREFIX}utils_test" }
+  let(:api_instance) { Manticore::Client::UtilsApi.new }
+
+  before do
+    # Create a test table
+    sql = "CREATE TABLE #{table_name} (title text, rating float)"
+    api_instance.sql("query=#{URI.encode_www_form_component(sql)}", query_params: { mode: "raw" })
+  end
+
+  after do
+    # Drop the test table
+
+    sql = "DROP TABLE #{table_name}"
+    api_instance.sql("query=#{URI.encode_www_form_component(sql)}", query_params: { mode: "raw" })
+  rescue StandardError => e
+    puts "Warning: Could not drop table #{table_name}: #{e.message}"
+  end
+
+  describe "#sql" do
+    it "creates an instance of UtilsApi" do
+      expect(api_instance).to be_instance_of(Manticore::Client::UtilsApi)
+    end
+
+    it "executes INSERT statement" do
+      # Insert test data
+      sql = "INSERT INTO #{table_name} (id, title, rating) VALUES (1, 'Test Movie', 8.5)"
+      result = api_instance.sql("query=#{URI.encode_www_form_component(sql)}", query_params: { mode: "raw" })
+
+      # Verify the result
+      expect(result).to be_an(Array)
+      expect(result.first[:total]).to eq(1) # 1 row affected
+      expect(result.first[:error]).to be_empty
+    end
+
+    it "executes SELECT statement" do
+      # Insert test data
+      sql = "INSERT INTO #{table_name} (id, title, rating) VALUES (1, 'Test Movie', 8.5)"
+      api_instance.sql("query=#{URI.encode_www_form_component(sql)}", query_params: { mode: "raw" })
+
+      # Query the data
+      sql = "SELECT * FROM #{table_name}"
+      result = api_instance.sql("query=#{URI.encode_www_form_component(sql)}", query_params: { mode: "raw" })
+
+      # Verify the result
+      expect(result).to be_an(Array)
+      expect(result.first[:data]).to be_an(Array)
+      expect(result.first[:data].size).to eq(1)
+      expect(result.first[:data].first[:title]).to eq("Test Movie")
+      expect(result.first[:data].first[:rating]).to eq(8.5)
+    end
+
+    it "executes SHOW TABLES statement" do
+      # Query tables
+      sql = "SHOW TABLES"
+      result = api_instance.sql("query=#{URI.encode_www_form_component(sql)}", query_params: { mode: "raw" })
+
+      # Verify the result
+      expect(result).to be_an(Array)
+      expect(result.first[:columns]).to be_an(Array)
+      expect(result.first[:data]).to be_an(Array)
+
+      # The test table should be in the list
+      table_names = result.first[:data].map { |row| row[:Table] }
+      expect(table_names).to include(table_name)
+    end
+
+    it "handles errors gracefully" do
+      # Execute an invalid SQL statement
+      sql = "SELECT * FROM non_existent_table"
+
+      # The API should raise an exception
+      expect { api_instance.sql("query=#{URI.encode_www_form_component(sql)}", query_params: { mode: "raw" }) }
+        .to raise_error(Manticore::Client::ApiError) do |error|
+        expect(error.response_body).to include("error")
+      end
+    end
+
+    it "supports raw_response parameter" do
+      # Insert test data
+      sql = "INSERT INTO #{table_name} (id, title, rating) VALUES (2, 'Another Movie', 7.0)"
+      api_instance.sql("query=#{URI.encode_www_form_component(sql)}", query_params: { mode: "raw" })
+
+      # Query with raw_response=false and mode=raw
+      sql = "SELECT * FROM #{table_name} WHERE id = 2"
+      result = api_instance.sql("query=#{URI.encode_www_form_component(sql)}",
+                                query_params: { raw_response: false, mode: "raw" })
+
+      # Verify the result format is different with raw_response=false
+      expect(result).to be_an(Array)
+      expect(result.first[:data]).to be_an(Array)
+      expect(result.first[:data].size).to eq(1)
+      expect(result.first[:data].first[:title]).to eq("Another Movie")
+    end
+  end
+end