algolia 3.34.3 → 3.35.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 1db63a1b903c40427512010e991ee81e6bf594486711c26a694d20a4d7f46a14
-  data.tar.gz: ad4231553e54fd5a0b585e976d9cada33b6d0965066879aaacbc4bf34c6bb2cf
+  metadata.gz: ed9225f3ee712ee510d7e5ec50de5224f13c3c6ec128ab8ce321a2f37515000c
+  data.tar.gz: d5b7a0e0bc1f1fda4ec306f4ad83949b8e2235136463baeff81a6ac833d631f7
 SHA512:
-  metadata.gz: d426e45713dd051dc7cc0f19a901971aa7d465fc8a4b2e5e1fdbd1f515c67dcfe40ea919e0b518123581560dfc2e69d677a52c4f86f46cbd1431fec322bd89e3
-  data.tar.gz: dba20a8fd6f82fd0203081d818bba3ab664e5176c07f6f60a96583baefcc10024aa1b7fae79bff8ee61688258d0b7118fa908fba197dc0ccb25f677559eec1be
+  metadata.gz: 3f3f07f51bb0ef9f91c64b91f83756b6ef1be282568df60911c0e9bcef6fbc7a07c431fc72266b6ac557f46e372bfa1b34e91e1ccc168971c0588d8040a487af
+  data.tar.gz: 20e2455d1b6bf30b08b8aa048bf19bc1bb0c180bee3c235e4c8471364df289abe83c5c01b1dfd91b21a9468100ab75815be68f5821e3fc512cbf9d2a18ec2a1f

data/.github/workflows/release.yml

@@ -21,7 +21,7 @@ jobs:
       - name: Install Ruby
         uses: ruby/setup-ruby@v1
         with:
-          ruby-version: 4.0.0
+          ruby-version: 4.0.1
           bundler-cache: true
 
       - uses: rubygems/release-gem@1c162a739e8b4cb21a676e97b087e8268d8fc40b

data/AGENTS.md

@@ -0,0 +1,182 @@
+# RUBY CLIENT - AI AGENT INSTRUCTIONS
+
+## ⚠️ CRITICAL: CHECK YOUR REPOSITORY FIRST
+
+Before making ANY changes, verify you're in the correct repository:
+
+```bash
+git remote -v
+```
+
+- ✅ **CORRECT**: `origin .../algolia/api-clients-automation.git` → You may proceed
+- ❌ **WRONG**: `origin .../algolia/algoliasearch-client-ruby.git` → STOP! This is the PUBLIC repository
+
+**If you're in `algoliasearch-client-ruby`**: Do NOT make changes here. All changes must go through `api-clients-automation`. PRs and commits made directly to the public repo will be discarded on next release.
+
+## ⚠️ BEFORE ANY EDIT: Check If File Is Generated
+
+Before editing ANY file, verify it's hand-written by checking `config/generation.config.mjs`:
+
+```javascript
+// In generation.config.mjs - patterns WITHOUT '!' are GENERATED (do not edit)
+'clients/algoliasearch-client-ruby/lib/algolia/**',           // Generated
+'!clients/algoliasearch-client-ruby/lib/algolia/transport/**', // Hand-written ✓
+'!clients/algoliasearch-client-ruby/lib/algolia/error.rb',     // Hand-written ✓
+```
+
+**Hand-written (safe to edit):**
+
+- `lib/algolia/transport/**` - Transport, retry strategy, HTTP handling
+- `lib/algolia/api_client.rb` - Core API client
+- `lib/algolia/api_error.rb` - API error class
+- `lib/algolia/configuration.rb` - Configuration
+- `lib/algolia/error.rb` - Error base class
+- `lib/algolia/logger_helper.rb` - Logging utilities
+- `lib/algolia/user_agent.rb` - User agent handling
+
+**Generated (DO NOT EDIT):**
+
+- `lib/algolia/api/**` - API client classes
+- `lib/algolia/models/**` - API models
+- `Gemfile.lock`, `version.rb`
+
+## Language Conventions
+
+### Naming
+
+- **Files**: `snake_case.rb`
+- **Classes/Modules**: `PascalCase`
+- **Methods/Variables**: `snake_case`
+- **Constants**: `UPPER_SNAKE_CASE`
+- **Predicates**: `method_name?` (returns boolean)
+- **Dangerous methods**: `method_name!` (mutates or raises)
+
+### Formatting
+
+- RubyFmt for formatting
+- Run: `yarn cli format ruby clients/algoliasearch-client-ruby`
+
+### Ruby Idioms
+
+- Use `attr_reader`, `attr_accessor` for accessors
+- Prefer `||=` for memoization
+- Use `&.` safe navigation operator
+- Blocks over lambdas for callbacks
+
+### Dependencies
+
+- **HTTP**: Faraday (with Net::HTTP adapter)
+- **Build**: Bundler + gemspec
+- **Versions**: Ruby 3.4+
+
+## Client Patterns
+
+### Transport Architecture
+
+```ruby
+# lib/algolia/transport/
+class Transport
+  def initialize(config)
+    @http_requester = HttpRequester.new(config.app_id, config.api_key)
+    @retry_strategy = RetryStrategy.new(config.hosts)
+  end
+
+  def request(method, path, body, opts)
+    # Retry with host failover
+  end
+end
+```
+
+### Retry Strategy
+
+```ruby
+# lib/algolia/transport/retry_strategy.rb
+class RetryStrategy
+  # Host states: :up, :down, :timed_out
+  # Retries on network errors
+  # 4xx errors not retried
+end
+```
+
+### Configuration
+
+```ruby
+# Configuration object pattern
+config = Algolia::Configuration.new(
+  app_id: 'APP_ID',
+  api_key: 'API_KEY',
+  hosts: [...],
+  read_timeout: 5,
+  write_timeout: 30
+)
+```
+
+## Common Gotchas
+
+### Symbol vs String Keys
+
+```ruby
+# API returns string keys, use with_indifferent_access or symbols
+response[:hits]      # May not work
+response['hits']     # Works
+response.hits        # Works if using model objects
+```
+
+### Block Syntax
+
+```ruby
+# Use do..end for multi-line, braces for single-line
+client.search { |r| r.query = 'test' }
+
+client.search do |params|
+  params.query = 'test'
+  params.hits_per_page = 10
+end
+```
+
+### Error Handling
+
+```ruby
+begin
+  response = client.search(params)
+rescue Algolia::AlgoliaError => e
+  # Base error class
+rescue Algolia::ApiError => e
+  # API returned error
+  puts e.status_code
+  puts e.message
+end
+```
+
+### Nil Safety
+
+```ruby
+# Use safe navigation
+result&.hits&.first&.object_id
+
+# Or explicit checks
+if result && result.hits && result.hits.any?
+  result.hits.first.object_id
+end
+```
+
+### Deprecated Operations
+
+Some operations in `ingestion_client.rb` and `search_client.rb` are deprecated. Check method documentation before use.
+
+## Build & Test Commands
+
+```bash
+# From repo root (api-clients-automation)
+yarn cli build clients ruby                    # Build Ruby client
+yarn cli cts generate ruby                     # Generate CTS tests
+yarn cli cts run ruby                          # Run CTS tests
+yarn cli playground ruby search                # Interactive playground
+yarn cli format ruby clients/algoliasearch-client-ruby
+
+# From client directory
+cd clients/algoliasearch-client-ruby
+bundle install                                 # Install dependencies
+bundle exec rake test                          # Run tests
+bundle exec rubocop                            # Run linter
+```

data/CHANGELOG.md

@@ -1,3 +1,23 @@
+## [3.35.0](https://github.com/algolia/algoliasearch-client-ruby/compare/3.34.4...3.35.0)
+
+BREAKING CHANGES: this minor version includes multiple breaking changes related to fixes on different APIs. See below for more details.
+
+- [b39e3e013](https://github.com/algolia/api-clients-automation/commit/b39e3e013) feat(specs): `conditions` is not required anymore in composition rules ([#5853](https://github.com/algolia/api-clients-automation/pull/5853)) by [@ClaraMuller](https://github.com/ClaraMuller/)
+- [9ef126ccd](https://github.com/algolia/api-clients-automation/commit/9ef126ccd) docs(SearchParams): Document that filter scores are supported in virtual replicas ([#5716](https://github.com/algolia/api-clients-automation/pull/5716)) by [@NixFrog](https://github.com/NixFrog/)
+- [6a3e60802](https://github.com/algolia/api-clients-automation/commit/6a3e60802) fix(specs): BREAKING CHANGE – remove baseRecommendRequest from trendingFacets [CR-10264] ([#5858](https://github.com/algolia/api-clients-automation/pull/5858)) by [@raed667](https://github.com/raed667/)
+  - The `TrendingFacets` model has been updated to reflect the API response.
+- [f9453e693](https://github.com/algolia/api-clients-automation/commit/f9453e693) docs: BREAKING CHANGE – authentication type can't be updated ([#5824](https://github.com/algolia/api-clients-automation/pull/5824)) by [@sbellone](https://github.com/sbellone/)
+  - The `AuthenticationUpdate` model has been updated to reflect that the `type` field can't be updated.
+- [52aed5b35](https://github.com/algolia/api-clients-automation/commit/52aed5b35) fix(specs): allow additionalProperties on insights-api events ([#5885](https://github.com/algolia/api-clients-automation/pull/5885)) by [@sirockin](https://github.com/sirockin/)
+- [2925f56d1](https://github.com/algolia/api-clients-automation/commit/2925f56d1) fix(specs): BREAKING CHANGE – more accurate composition behavior typing ([#5892](https://github.com/algolia/api-clients-automation/pull/5892)) by [@gavinwade12](https://github.com/gavinwade12/)
+  - The `CompositionBehavior` model is now a union type for better accuracy.
+- [63b0c5464](https://github.com/algolia/api-clients-automation/commit/63b0c5464) feat(specs): BREAKING CHANGE – Ingestion API: new `code` property in oauth authentication ([#5897](https://github.com/algolia/api-clients-automation/pull/5897)) by [@sbellone](https://github.com/sbellone/)
+  - The `AuthOAuth` and `AuthOAuthPartial` models have been updated to reflect that the `clientId` field is now optional, and the `code` field can be set.
+
+## [3.34.4](https://github.com/algolia/algoliasearch-client-ruby/compare/3.34.3...3.34.4)
+
+- [f02ab6fa0](https://github.com/algolia/api-clients-automation/commit/f02ab6fa0) chore: agentic config prep ([#5825](https://github.com/algolia/api-clients-automation/pull/5825)) by [@Fluf22](https://github.com/Fluf22/)
+
 ## [3.34.3](https://github.com/algolia/algoliasearch-client-ruby/compare/3.34.2...3.34.3)
 
 - [cd7a174b4](https://github.com/algolia/api-clients-automation/commit/cd7a174b4) fix(specs): BREAKING CHANGE — remove fields requirement from run response in CompAPI client ([#5809](https://github.com/algolia/api-clients-automation/pull/5809)) by [@ClaraMuller](https://github.com/ClaraMuller/)\

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    algolia (3.34.3)
+    algolia (3.35.0)
       base64 (>= 0.2.0, < 1)
       faraday (>= 1.0.1, < 3.0)
       faraday-net_http_persistent (>= 0.15, < 3)

data/lib/algolia/models/composition/composition_behavior.rb

@@ -7,200 +7,101 @@ require "time"
 
 module Algolia
   module Composition
-    class CompositionBehavior
-      attr_accessor :injection
-
-      # Attribute mapping from ruby-style variable name to JSON key.
-      def self.attribute_map
-        {
-          :injection => :injection
-        }
-      end
-
-      # Attribute type mapping.
-      def self.types_mapping
-        {
-          :injection => :"Injection"
-        }
-      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))
-          raise(
-            ArgumentError,
-            "The input argument (attributes) must be a hash in `Algolia::CompositionBehavior` initialize method"
-          )
+    # An object containing either an `injection` or `multifeed` behavior schema, but not both.
+    module CompositionBehavior
+      class << self
+      # List of class defined in oneOf (OpenAPI v3)
+        def openapi_one_of
+          [
+            :"CompositionInjectionBehavior",
+            :"CompositionMultifeedBehavior"
+          ]
         end
 
-        # check to see if the attribute exists and convert string to symbol for hash key
-        attributes = attributes.each_with_object({}) { |(k, v), h|
-          if (!self.class.attribute_map.key?(k.to_sym))
-            raise(
-              ArgumentError,
-              "`#{k}` is not a valid attribute in `Algolia::CompositionBehavior`. Please check the name to make sure it's valid. List of attributes: " +
-                self.class.attribute_map.keys.inspect
-            )
+        # Builds the object
+        # @param [Mixed] Data to be matched against the list of oneOf items
+        # @return [Object] Returns the model or the data itself
+        def build(data)
+          # Go through the list of oneOf items and attempt to identify the appropriate one.
+          # Note:
+          # - We do not attempt to check whether exactly one item matches.
+          # - No advanced validation of types in some cases (e.g. "x: { type: string }" will happily match { x: 123 })
+          #   due to the way the deserialization is made in the base_object template (it just casts without verifying).
+          # - TODO: scalar values are de facto behaving as if they were nullable.
+          # - TODO: logging when debugging is set.
+          openapi_one_of.each do |klass|
+            begin
+              # "nullable: true"
+              next if klass == :AnyType
+              typed_data = find_and_cast_into_type(klass, data)
+              return typed_data if typed_data
+              # rescue all errors so we keep iterating even if the current item lookup raises
+            rescue
+            end
           end
 
-          h[k.to_sym] = v
-        }
-
-        if attributes.key?(:injection)
-          self.injection = attributes[:injection]
-        else
-          self.injection = nil
+          openapi_one_of.include?(:AnyType) ? data : nil
         end
-      end
 
-      # Checks equality by comparing each attribute.
-      # @param [Object] Object to be compared
-      def ==(other)
-        return true if self.equal?(other)
-        self.class == other.class &&
-          injection == other.injection
-      end
-
-      # @see the `==` method
-      # @param [Object] Object to be compared
-      def eql?(other)
-        self == other
-      end
-
-      # Calculates hash code according to all attributes.
-      # @return [Integer] Hash code
-      def hash
-        [injection].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 = {}
-        types_mapping.each_pair do |key, type|
-          if attributes.key?(attribute_map[key]) && attributes[attribute_map[key]].nil?
-            transformed_hash[key.to_sym] = 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.to_sym] = attributes[attribute_map[key]].map { |v|
-                _deserialize(::Regexp.last_match(1), v)
-              }
+        private
+
+        SchemaMismatchError = Class.new(StandardError)
+
+        def find_and_cast_into_type(klass, data)
+          return if data.nil?
+
+          case klass.to_s
+          when "Boolean"
+            return data if data.instance_of?(TrueClass) || data.instance_of?(FalseClass)
+          when "Float"
+            return data if data.instance_of?(Float)
+          when "Integer"
+            return data if data.instance_of?(Integer)
+          when "Time"
+            return Time.parse(data)
+          when "Date"
+            return Date.parse(data)
+          when "String"
+            return data if data.instance_of?(String)
+            # "type: object"
+          when "Object"
+            return data if data.instance_of?(Hash)
+            # "type: array"
+          when /\AArray<(?<sub_type>.+)>\z/
+            if data.instance_of?(Array)
+              sub_type = Regexp.last_match[:sub_type]
+              return data.map { |item| find_and_cast_into_type(sub_type, item) }
             end
-          elsif !attributes[attribute_map[key]].nil?
-            transformed_hash[key.to_sym] = _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
+            # "type: object" with "additionalProperties: { ... }"
+          when /\AHash<String, (?<sub_type>.+)>\z/
+            if data.instance_of?(Hash) && data.keys.all? { |k| k.instance_of?(Symbol) || k.instance_of?(String) }
+              sub_type = Regexp.last_match[:sub_type]
+              return data.each_with_object({}) { |(k, v), hsh| hsh[k] = find_and_cast_into_type(sub_type, v) }
+            end
+            # model
           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)
+            const = Algolia::Composition.const_get(klass)
+            if const
+              if const.respond_to?(:openapi_one_of)
+                # nested oneOf model
+                model = const.build(data)
+              elsif const.respond_to?(:discriminator_attributes)
+                if const.discriminator_attributes.all? { |attr| data.key?(attr) }
+                  model = const.build_from_hash(data)
+                end
+              else
+                # maybe it's an enum, or doens't have discriminators
+                model = const.build_from_hash(data)
+              end
+
+              return model if model
             end
           end
-          # model
-        else
-          # models (e.g. Pet) or oneOf
-          klass = Algolia::Composition.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
 
-      def to_json(*_args)
-        to_hash.to_json
-      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 = 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
+          # if no match by now, raise
+          raise
+        rescue
+          raise SchemaMismatchError, "#{data} doesn't match the #{klass} type"
         end
       end
     end