elasticsearch-api 7.13.3 → 8.14.0

data/lib/elasticsearch/api/namespace/synonyms.rb

@@ -0,0 +1,36 @@
+# Licensed to Elasticsearch B.V. under one or more contributor
+# license agreements. See the NOTICE file distributed with
+# this work for additional information regarding copyright
+# ownership. Elasticsearch B.V. licenses this file to you 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.
+
+module Elasticsearch
+  module API
+    module Synonyms
+      module Actions; end
+
+      # Client for the "synonyms" namespace (includes the {Synonyms::Actions} methods)
+      #
+      class SynonymsClient
+        include Common::Client, Common::Client::Base, Synonyms::Actions
+      end
+
+      # Proxy method for {SynonymsClient}, available in the receiving object
+      #
+      def synonyms
+        @synonyms ||= SynonymsClient.new(self)
+      end
+    end
+  end
+end

data/lib/elasticsearch/api/namespace/text_structure.rb

@@ -0,0 +1,36 @@
+# Licensed to Elasticsearch B.V. under one or more contributor
+# license agreements. See the NOTICE file distributed with
+# this work for additional information regarding copyright
+# ownership. Elasticsearch B.V. licenses this file to you 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.
+
+module Elasticsearch
+  module API
+    module TextStructure
+      module Actions; end
+
+      # Client for the "text_structure" namespace (includes the {TextStructure::Actions} methods)
+      #
+      class TextStructureClient
+        include Common::Client, Common::Client::Base, TextStructure::Actions
+      end
+
+      # Proxy method for {TextStructureClient}, available in the receiving object
+      #
+      def text_structure
+        @text_structure ||= TextStructureClient.new(self)
+      end
+    end
+  end
+end

data/lib/elasticsearch/api/namespace/transform.rb

@@ -0,0 +1,36 @@
+# Licensed to Elasticsearch B.V. under one or more contributor
+# license agreements. See the NOTICE file distributed with
+# this work for additional information regarding copyright
+# ownership. Elasticsearch B.V. licenses this file to you 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.
+
+module Elasticsearch
+  module API
+    module Transform
+      module Actions; end
+
+      # Client for the "transform" namespace (includes the {Transform::Actions} methods)
+      #
+      class TransformClient
+        include Common::Client, Common::Client::Base, Transform::Actions
+      end
+
+      # Proxy method for {TransformClient}, available in the receiving object
+      #
+      def transform
+        @transform ||= TransformClient.new(self)
+      end
+    end
+  end
+end

data/lib/elasticsearch/api/namespace/watcher.rb

@@ -0,0 +1,36 @@
+# Licensed to Elasticsearch B.V. under one or more contributor
+# license agreements. See the NOTICE file distributed with
+# this work for additional information regarding copyright
+# ownership. Elasticsearch B.V. licenses this file to you 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.
+
+module Elasticsearch
+  module API
+    module Watcher
+      module Actions; end
+
+      # Client for the "watcher" namespace (includes the {Watcher::Actions} methods)
+      #
+      class WatcherClient
+        include Common::Client, Common::Client::Base, Watcher::Actions
+      end
+
+      # Proxy method for {WatcherClient}, available in the receiving object
+      #
+      def watcher
+        @watcher ||= WatcherClient.new(self)
+      end
+    end
+  end
+end

data/lib/elasticsearch/api/namespace/xpack.rb

@@ -0,0 +1,36 @@
+# Licensed to Elasticsearch B.V. under one or more contributor
+# license agreements. See the NOTICE file distributed with
+# this work for additional information regarding copyright
+# ownership. Elasticsearch B.V. licenses this file to you 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.
+
+module Elasticsearch
+  module API
+    module XPack
+      module Actions; end
+
+      # Client for the "xpack" namespace (includes the {XPack::Actions} methods)
+      #
+      class XPackClient
+        include Common::Client, Common::Client::Base, XPack::Actions
+      end
+
+      # Proxy method for {XPackClient}, available in the receiving object
+      #
+      def xpack
+        @xpack ||= XPackClient.new(self)
+      end
+    end
+  end
+end

data/lib/elasticsearch/api/response.rb

@@ -0,0 +1,48 @@
+# Licensed to Elasticsearch B.V. under one or more contributor
+# license agreements. See the NOTICE file distributed with
+# this work for additional information regarding copyright
+# ownership. Elasticsearch B.V. licenses this file to you 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.
+
+module Elasticsearch
+  module API
+    # Elasticsearch client API Response object. Receives an Elastic::Transport::Transport::Response in
+    # the initializer and behaves like a Hash, except when status or headers are called upon it, in
+    # which case it returns the original object's status and headers.
+    class Response
+      RESPONSE_METHODS = [:status, :body, :headers]
+
+      def initialize(response)
+        @response = response
+      end
+
+      def method_missing(method, *args, &block)
+        if RESPONSE_METHODS.include? method
+          @response.send method.to_sym
+        else
+          @response.body.send(method.to_sym, *args, &block)
+        end
+      end
+
+      def respond_to_missing?(method_name, include_private = false)
+        @response.body.respond_to?(method_name, include_private) ||
+          RESPONSE_METHODS.include?(method_name)
+      end
+
+      def to_s
+        @response.body.to_s
+      end
+    end
+  end
+end

data/lib/elasticsearch/api/utils.rb

@@ -14,14 +14,13 @@
 # KIND, either express or implied.  See the License for the
 # specific language governing permissions and limitations
 # under the License.
+require 'erb'
 
 module Elasticsearch
   module API
-
     # Generic utility methods
     #
     module Utils
-
       # URL-escape a string
       #
       # @example
@@ -31,7 +30,7 @@ module Elasticsearch
       # @api private
       def __escape(string)
         return string if string == '*'
-        defined?(EscapeUtils) ? EscapeUtils.escape_url(string.to_s) : CGI.escape(string.to_s)
+        ERB::Util.url_encode(string.to_s)
       end
 
       # Create a "list" of values from arguments, ignoring nil values and encoding special characters.
@@ -130,54 +129,9 @@ module Elasticsearch
         payload = payload.join("\n")
       end
 
-      # Validates the argument Hash against common and valid API parameters
-      #
-      # @param arguments    [Hash]          Hash of arguments to verify and extract, **with symbolized keys**
-      # @param valid_params [Array<Symbol>] An array of symbols with valid keys
-      #
-      # @return [Hash]         Return whitelisted Hash
-      # @raise [ArgumentError] If the arguments Hash contains invalid keys
-      #
-      # @example Extract parameters
-      #   __validate_and_extract_params( { :foo => 'qux' }, [:foo, :bar] )
-      #   # => { :foo => 'qux' }
-      #
-      # @example Raise an exception for invalid parameters
-      #   __validate_and_extract_params( { :foo => 'qux', :bam => 'mux' }, [:foo, :bar] )
-      #   # ArgumentError: "URL parameter 'bam' is not supported"
-      #
-      # @example Skip validating parameters
-      #   __validate_and_extract_params( { :foo => 'q', :bam => 'm' }, [:foo, :bar], { skip_parameter_validation: true } )
-      #   # => { :foo => "q", :bam => "m" }
-      #
-      # @example Skip validating parameters when the module setting is set
-      #   Elasticsearch::API.settings[:skip_parameter_validation] = true
-      #   __validate_and_extract_params( { :foo => 'q', :bam => 'm' }, [:foo, :bar] )
-      #   # => { :foo => "q", :bam => "m" }
-      #
-      # @api private
-      #
-      def __validate_and_extract_params(arguments, params=[], options={})
-        if options[:skip_parameter_validation] || Elasticsearch::API.settings[:skip_parameter_validation]
-          arguments
-        else
-          __validate_params(arguments, params)
-          __extract_params(arguments, params, options.merge(:escape => false))
-        end
-      end
-
-      def __validate_params(arguments, valid_params=[])
-        arguments.each do |k,v|
-          raise ArgumentError, "URL parameter '#{k}' is not supported" \
-            unless COMMON_PARAMS.include?(k) || COMMON_QUERY_PARAMS.include?(k) || valid_params.include?(k)
-        end
-      end
-
-      def __extract_params(arguments, params=[], options={})
-        result = arguments.select { |k,v| COMMON_QUERY_PARAMS.include?(k) || params.include?(k) }
-        result = Hash[result] unless result.is_a?(Hash) # Normalize Ruby 1.8 and Ruby 1.9 Hash#select behaviour
-        result = Hash[result.map { |k,v| v.is_a?(Array) ? [k, __listify(v, options)] : [k,v]  }] # Listify Arrays
-        result
+      def process_params(arguments)
+        arguments = Hash[arguments] unless arguments.is_a?(Hash)
+        Hash[arguments.map { |k, v| v.is_a?(Array) ? [k, __listify(v, { escape: false })] : [k, v] }] # Listify Arrays
       end
 
       # Extracts the valid parts of the URL from the arguments
@@ -197,11 +151,7 @@ module Elasticsearch
       # @api private
       #
       def __extract_parts(arguments, valid_parts=[])
-        parts = Hash[arguments.select { |k,v| valid_parts.include?(k) }]
-        parts = parts.reduce([]) { |sum, item| k, v = item; v.is_a?(TrueClass) ? sum << k.to_s : sum << v  }
-
-        arguments.delete_if { |k,v| valid_parts.include? k }
-        return parts
+        Hash[arguments].reduce([]) { |sum, item| k, v = item; v.is_a?(TrueClass) ? sum << k.to_s : sum << v  }
       end
 
       # Calls the given block, rescuing from `StandardError`.

data/lib/elasticsearch/api/version.rb

@@ -17,6 +17,6 @@
 
 module Elasticsearch
   module API
-    VERSION = '7.13.3'.freeze
+    VERSION = '8.14.0'.freeze
   end
 end

data/lib/elasticsearch/api.rb

@@ -21,9 +21,8 @@ require "multi_json"
 require "elasticsearch/api/version"
 require "elasticsearch/api/namespace/common"
 require "elasticsearch/api/utils"
-require "elasticsearch/api/actions/params_registry"
+require 'elasticsearch/api/response'
 
-Dir[ File.expand_path('../api/actions/**/params_registry.rb', __FILE__) ].each   { |f| require f }
 Dir[ File.expand_path('../api/actions/**/*.rb', __FILE__) ].each   { |f| require f }
 Dir[ File.expand_path('../api/namespace/**/*.rb', __FILE__) ].each { |f| require f }
 
@@ -31,24 +30,6 @@ module Elasticsearch
   module API
     DEFAULT_SERIALIZER = MultiJson
 
-    COMMON_PARAMS = [
-      :ignore,                        # Client specific parameters
-      :index, :type, :id,             # :index/:type/:id
-      :body,                          # Request body
-      :node_id,                       # Cluster
-      :name,                          # Alias, template, settings, warmer, ...
-      :field                          # Get field mapping
-    ]
-
-    COMMON_QUERY_PARAMS = [
-      :ignore,                        # Client specific parameters
-      :format,                        # Search, Cat, ...
-      :pretty,                        # Pretty-print the response
-      :human,                         # Return numeric values in human readable format
-      :filter_path,                   # Filter the JSON response
-      :opaque_id                      # Use X-Opaque-Id
-    ]
-
     HTTP_GET          = 'GET'.freeze
     HTTP_HEAD         = 'HEAD'.freeze
     HTTP_POST         = 'POST'.freeze
@@ -74,7 +55,39 @@ module Elasticsearch
                 Elasticsearch::API::Remote,
                 Elasticsearch::API::DanglingIndices,
                 Elasticsearch::API::Features,
-                Elasticsearch::API::Shutdown
+                Elasticsearch::API::Shutdown,
+                Elasticsearch::API::AsyncSearch,
+                Elasticsearch::API::Autoscaling,
+                Elasticsearch::API::CrossClusterReplication,
+                Elasticsearch::API::DataFrameTransformDeprecated,
+                Elasticsearch::API::Enrich,
+                Elasticsearch::API::Eql,
+                Elasticsearch::API::Fleet,
+                Elasticsearch::API::Graph,
+                Elasticsearch::API::IndexLifecycleManagement,
+                Elasticsearch::API::License,
+                Elasticsearch::API::Logstash,
+                Elasticsearch::API::Migration,
+                Elasticsearch::API::MachineLearning,
+                Elasticsearch::API::Monitoring,
+                Elasticsearch::API::Rollup,
+                Elasticsearch::API::SearchableSnapshots,
+                Elasticsearch::API::Security,
+                Elasticsearch::API::SnapshotLifecycleManagement,
+                Elasticsearch::API::SQL,
+                Elasticsearch::API::SSL,
+                Elasticsearch::API::TextStructure,
+                Elasticsearch::API::Transform,
+                Elasticsearch::API::Watcher,
+                Elasticsearch::API::XPack,
+                Elasticsearch::API::SearchApplication,
+                Elasticsearch::API::Synonyms,
+                Elasticsearch::API::QueryRuleset,
+                Elasticsearch::API::Esql,
+                Elasticsearch::API::Inference,
+                Elasticsearch::API::Profiling,
+                Elasticsearch::API::Simulate,
+                Elasticsearch::API::Connector
     end
 
     # The serializer class

data/spec/elasticsearch/api/actions/bulk_spec.rb

@@ -18,14 +18,14 @@
 require 'spec_helper'
 
 describe 'client#bulk' do
-
   let(:expected_args) do
     [
         'POST',
         url,
         params,
         body,
-        headers
+        headers,
+        {:endpoint=>"bulk"}
     ]
   end
 
@@ -35,105 +35,109 @@ describe 'client#bulk' do
   let(:body) { '' }
 
   context 'when a list of operations is provided' do
-
     let(:body) do
       <<-PAYLOAD.gsub(/^\s+/, '')
-        {"index":{"_index":"myindexA","_type":"mytype","_id":"1"}}
+        {"index":{"_index":"myindexA","_id":"1"}}
         {"title":"Test"}
-        {"update":{"_index":"myindexB","_type":"mytype","_id":"2"}}
+        {"update":{"_index":"myindexB","_id":"2"}}
         {"doc":{"title":"Update"}}
-        {"delete":{"_index":"myindexC","_type":"mytypeC","_id":"3"}}
-        {"index":{"_index":"myindexD","_type":"mytype","_id":"1"}}
+        {"delete":{"_index":"myindexC","_id":"3"}}
+        {"index":{"_index":"myindexD","_id":"1"}}
         {"data":"MYDATA"}
       PAYLOAD
     end
 
     it 'performs the request' do
       expect(client_double.bulk(:body => [
-          { :index =>  { :_index => 'myindexA', :_type => 'mytype', :_id => '1', :data => { :title => 'Test' } } },
-          { :update => { :_index => 'myindexB', :_type => 'mytype', :_id => '2', :data => { :doc => { :title => 'Update' } } } },
-          { :delete => { :_index => 'myindexC', :_type => 'mytypeC', :_id => '3' } },
-          { :index =>  { :_index => 'myindexD', :_type => 'mytype', :_id => '1', :data => { :data => 'MYDATA' } } },
-      ])).to eq({})
+          { :index =>  { :_index => 'myindexA', :_id => '1', :data => { :title => 'Test' } } },
+          { :update => { :_index => 'myindexB', :_id => '2', :data => { :doc => { :title => 'Update' } } } },
+          { :delete => { :_index => 'myindexC', :_id => '3' } },
+          { :index =>  { :_index => 'myindexD', :_id => '1', :data => { :data => 'MYDATA' } } },
+      ])).to be_a Elasticsearch::API::Response
     end
   end
 
   context 'when an index is specified' do
-
     let(:url) { 'myindex/_bulk' }
 
+    let(:expected_args) do
+      [
+        'POST',
+        url,
+        params,
+        body,
+        headers,
+        { defined_params: { index: 'myindex' }, :endpoint=>"bulk"}
+      ]
+    end
+
     it 'performs the request' do
-      expect(client_double.bulk(index: 'myindex', body: [])).to eq({})
+      expect(client_double.bulk(index: 'myindex', body: [])).to be_a Elasticsearch::API::Response
     end
   end
 
   context 'when there are data keys in the head/data payloads' do
-
     let(:body) do
       <<-PAYLOAD.gsub(/^\s+/, '')
-        {"update":{"_index":"myindex","_type":"mytype","_id":"1"}}
+        {"update":{"_index":"myindex","_id":"1"}}
         {"doc":{"data":{"title":"Update"}}}
       PAYLOAD
     end
 
     it 'performs the request' do
-      expect(client_double.bulk(body:[ { :update => { :_index => 'myindex', :_type => 'mytype', :_id => '1' } },
-                                       { :doc => { :data => { :title => 'Update' } } } ])).to eq({})
+      expect(client_double.bulk(body:[ { :update => { :_index => 'myindex', :_id => '1' } },
+                                       { :doc => { :data => { :title => 'Update' } } } ])).to be_a Elasticsearch::API::Response
     end
   end
 
   context 'when the payload is a string' do
-
     let(:body) do
       'foo\nbar'
     end
 
     it 'performs the request' do
-      expect(client_double.bulk(body: 'foo\nbar')).to eq({})
+      expect(client_double.bulk(body: 'foo\nbar')).to be_a Elasticsearch::API::Response
     end
   end
 
   context 'when the payload is an array of Strings' do
-
     let(:body) do
       "foo\nbar\n"
     end
 
     it 'performs the request' do
-      expect(client_double.bulk(body: ['foo', 'bar'])).to eq({})
+      expect(client_double.bulk(body: ['foo', 'bar'])).to be_a Elasticsearch::API::Response
     end
   end
 
   context 'when there are parameters' do
-
     let(:params) do
       { refresh: true }
     end
 
     it 'performs the request' do
-      expect(client_double.bulk(refresh: true, body: [])).to eq({})
+      expect(client_double.bulk(refresh: true, body: [])).to be_a Elasticsearch::API::Response
     end
   end
 
   context 'when url characters need to be URL-escaped' do
-
     let(:url) do
       'foo%5Ebar/_bulk'
     end
 
-    it 'performs the request' do
-      expect(client_double.bulk(index: 'foo^bar', body: [])).to eq({})
-    end
-  end
-
-  context 'when the type is provided' do
-
-    let(:url) do
-      'myindex/mytype/_bulk'
+    let(:expected_args) do
+      [
+        'POST',
+        url,
+        params,
+        body,
+        headers,
+        { defined_params: { index: 'foo^bar' }, :endpoint=>"bulk"}
+      ]
     end
 
     it 'performs the request' do
-      expect(client_double.bulk(index: 'myindex', type: 'mytype', body: [])).to eq({})
+      expect(client_double.bulk(index: 'foo^bar', body: [])).to be_a Elasticsearch::API::Response
     end
   end
 end

data/spec/elasticsearch/api/actions/cat/aliases_spec.rb

@@ -25,11 +25,12 @@ describe 'client.cat#aliases' do
         '_cat/aliases',
         {},
         nil,
-        {}
+        {},
+        { endpoint: 'cat.aliases' }
     ]
   end
 
   it 'performs the request' do
-    expect(client_double.cat.aliases).to eq({})
+    expect(client_double.cat.aliases).to be_a Elasticsearch::API::Response
   end
 end

data/spec/elasticsearch/api/actions/cat/allocation_spec.rb

@@ -25,11 +25,12 @@ describe 'client.cat#allocation' do
         '_cat/allocation',
         {},
         nil,
-        {}
+        {},
+        { endpoint: 'cat.allocation' }
     ]
   end
 
   it 'performs the request' do
-    expect(client_double.cat.allocation).to eq({})
+    expect(client_double.cat.allocation).to be_a Elasticsearch::API::Response
   end
 end

data/spec/elasticsearch/api/actions/cat/component_templates_spec.rb

@@ -0,0 +1,58 @@
+# Licensed to Elasticsearch B.V. under one or more contributor
+# license agreements. See the NOTICE file distributed with
+# this work for additional information regarding copyright
+# ownership. Elasticsearch B.V. licenses this file to you under
+# the Apache License, Version 2.0 (the "License"); you may
+# not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#   http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+# KIND, either express or implied.  See the License for the
+# specific language governing permissions and limitations
+# under the License.
+
+require 'spec_helper'
+
+describe 'client.cat#component_templates' do
+  context 'without a name' do
+    let(:url) { '_cat/component_templates' }
+
+    let(:expected_args) do
+      [
+        'GET',
+        url,
+        {},
+        nil,
+        {},
+        { endpoint: 'cat.component_templates' }
+      ]
+    end
+
+    it 'performs the request' do
+      expect(client_double.cat.component_templates).to be_a Elasticsearch::API::Response
+    end
+  end
+
+  context 'with a name' do
+    let(:url) { '_cat/component_templates/foo' }
+
+    let(:expected_args) do
+      [
+        'GET',
+        url,
+        {},
+        nil,
+        {},
+        { defined_params: { name: 'foo' }, endpoint: 'cat.component_templates' }
+      ]
+    end
+
+    it 'performs the request' do
+      expect(client_double.cat.component_templates(name: 'foo')).to be_a Elasticsearch::API::Response
+    end
+  end
+end