noiseless 0.6.0 → 0.7.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 191caa0c33ef498748dcff326328dbd5e02b7f3a225ef1999b91127edb23490b
-  data.tar.gz: 3260bb7ca298d9b3ccdfb9e89a5a6e89759dbe56e2637b811439653cef4f9673
+  metadata.gz: 1b661712a5930c3da3a455f6e70c2d99cfbc424cf4e007c58abd587ab170854f
+  data.tar.gz: 547b60b50d5efb9b32da878523d96d5a58c5a7a645ab8bed13ebec40269370b7
 SHA512:
-  metadata.gz: eff7ee517dd4bea214b4602231baf34e518fc01546f3fe47f8b759aa75efb889aa6113bca2de56031b5ebf01ac893099217be4f5afc7af7c0802bf8686759601
-  data.tar.gz: f0cd3e05dafd3b3a86a7d6a278eac89a5230dbd859674fe209264e8b033a8ec75640a44d969ec1cf945e3ad414fa4137b9816871f1c05e9e30d1e6eb9957d6c9
+  metadata.gz: 17a625f20fb2c879f427d429c82ecb4b9c2b338ffec03bd69de83ee9c2b800800c57eaef0bb6f4d2e32876e91497c5b12bdf389a2f1edcb055bc228764b03473
+  data.tar.gz: 4799c4ba712b8d097b30553ac800caa798349d70c0ecbc7ca901b3f54752a9ed48ce2fcb4d3784d76117c0b7598801efc6f9e3685c5c945e34639740970a8d2e

data/lib/noiseless/adapter.rb

@@ -359,8 +359,8 @@ module Noiseless
     end
 
     def build_aggregations_hash(aggregations)
-      aggregations.each_with_object({}) do |agg, hash|
-        hash[agg.name] = build_single_aggregation(agg)
+      aggregations.to_h do |agg|
+        [agg.name, build_single_aggregation(agg)]
       end
     end
 

data/lib/noiseless/adapters/execution_modules/http_transport.rb

@@ -30,11 +30,27 @@ module Noiseless
         # +timeout:+.
         DEFAULT_TIMEOUT = 5
 
-        def initialize(hosts: [], timeout: DEFAULT_TIMEOUT, **connection_params)
+        # Default wall-clock deadline (seconds) for a complete round-trip:
+        # request write, response headers, and full body. The idle timeout
+        # above never trips against a backend that keeps trickling bytes —
+        # each read makes "progress" — which leaves callers blocked in
+        # Sync { ... .wait } indefinitely. This caps total duration instead.
+        # Override per-connection with +request_timeout:+; nil disables the
+        # deadline (long bulk imports may need a higher value or nil).
+        DEFAULT_REQUEST_TIMEOUT = 30
+
+        BufferedResponse = Struct.new(:status, :body) do
+          def read = body
+          def success? = (200..299).cover?(status)
+          def close = nil
+        end
+
+        def initialize(hosts: [], timeout: DEFAULT_TIMEOUT, request_timeout: DEFAULT_REQUEST_TIMEOUT, **connection_params)
           # Ensure we always have at least one host
           hosts_array = Array(hosts)
           @hosts = hosts_array.empty? ? ["http://localhost:#{default_port}"] : hosts_array
           @timeout = timeout
+          @request_timeout = request_timeout
           @connection_params = connection_params
 
           # Initialize HTTP clients for each host. The endpoint timeout makes a
@@ -95,7 +111,27 @@ module Noiseless
           host = @hosts.sample
           client = @clients[host]
 
-          wrap_transport_errors(host: host) { yield(client) }
+          wrap_transport_errors(host: host) do
+            with_request_deadline(host: host) do
+              buffer_response(yield(client))
+            end
+          end
+        end
+
+        def with_request_deadline(host:, &)
+          task = @request_timeout && Async::Task.current?
+          return yield unless task
+
+          task.with_timeout(@request_timeout, &)
+        rescue Async::TimeoutError
+          raise Noiseless::ConnectionError,
+                "search backend at #{host} exceeded request_timeout (#{@request_timeout}s wall-clock)"
+        end
+
+        def buffer_response(response)
+          BufferedResponse.new(response.status, response.read)
+        ensure
+          response.close
         end
 
         def parse_json_response!(response, error_class: Noiseless::RequestError, context: nil)

data/lib/noiseless/adapters/execution_modules/postgresql_execution.rb

@@ -24,9 +24,10 @@ module Noiseless
           return execute_vector_search(model, query_hash) if query_hash[:vector]
 
           scope = build_search_scope(model, query_hash)
-          records = scope.to_a
+          total = scope.except(:order, :limit, :offset).count
+          records = apply_pagination(scope, query_hash[:paginate]).to_a
 
-          format_as_search_response(records, model)
+          format_as_search_response(records, model, total: total)
         rescue StandardError => e
           error_response(e)
         end
@@ -39,7 +40,7 @@ module Noiseless
           scope = model.all
 
           # Apply any filters first
-          scope = apply_filter_clauses(scope, query_hash[:bool]&.filter || [])
+          scope = apply_filter_clauses(scope, query_hash[:bool]&.filter || [], model)
 
           # Apply vector search
           scope = vector_search(
@@ -104,43 +105,20 @@ module Noiseless
           false
         end
 
-        def execute_index_document(index, id, document, **)
-          model = resolve_model([index])
-          return { "_id" => id, "result" => "error", "error" => "Model not found" } unless model
-
-          record = model.find_or_initialize_by(id: id)
-          record.assign_attributes(document.slice(*model.column_names))
-          record.save!
-
-          { "_index" => index, "_id" => id, "result" => record.previously_new_record? ? "created" : "updated" }
-        rescue StandardError => e
-          { "_index" => index, "_id" => id, "result" => "error", "error" => e.message }
+        # Document writes are no-ops: the table IS the index, so queries always
+        # see current data. Writing indexed documents (which may be transformed
+        # by mappings) back into source rows would corrupt them, and deleting a
+        # record because its index entry was removed inverts ownership.
+        def execute_index_document(index, id, _document, **)
+          { "_index" => index, "_id" => id, "result" => "noop" }
         end
 
-        def execute_update_document(index, id, changes, **)
-          model = resolve_model([index])
-          return { "_id" => id, "result" => "error", "error" => "Model not found" } unless model
-
-          record = model.find(id)
-          record.update!(changes.slice(*model.column_names))
-
-          { "_index" => index, "_id" => id, "result" => "updated" }
-        rescue ActiveRecord::RecordNotFound
-          { "_index" => index, "_id" => id, "result" => "not_found" }
-        rescue StandardError => e
-          { "_index" => index, "_id" => id, "result" => "error", "error" => e.message }
+        def execute_update_document(index, id, _changes, **)
+          { "_index" => index, "_id" => id, "result" => "noop" }
         end
 
         def execute_delete_document(index, id, **)
-          model = resolve_model([index])
-          return { "_id" => id, "result" => "error", "error" => "Model not found" } unless model
-
-          model.destroy(id)
-          { "_index" => index, "_id" => id, "result" => "deleted" }
-        rescue ActiveRecord::RecordNotFound
-          { "_index" => index, "_id" => id, "result" => "not_found" }
-        rescue StandardError => e
-          { "_index" => index, "_id" => id, "result" => "error", "error" => e.message }
+          { "_index" => index, "_id" => id, "result" => "noop" }
         end
 
         def execute_document_exists?(index, id)
@@ -175,13 +153,10 @@ module Noiseless
           scope = apply_must_clauses(scope, query_hash[:bool]&.must || [], model)
 
           # Apply filter clauses (exact matches)
-          scope = apply_filter_clauses(scope, query_hash[:bool]&.filter || [])
-
-          # Apply sorting
-          scope = apply_sorting(scope, query_hash[:sort] || [])
+          scope = apply_filter_clauses(scope, query_hash[:bool]&.filter || [], model)
 
-          # Apply pagination
-          apply_pagination(scope, query_hash[:paginate])
+          # Apply sorting (pagination is applied by the caller, after counting)
+          apply_sorting(scope, query_hash[:sort] || [], model)
         end
 
         def apply_must_clauses(scope, must_nodes, model)
@@ -211,6 +186,10 @@ module Noiseless
           field = node.field.to_s
           value = node.value.to_s
 
+          # Mapping-only fields (denormalized into a search index, not columns)
+          # cannot be satisfied here; fail closed rather than matching everything.
+          return scope.none unless column?(model, field)
+
           # Use pg_trgm similarity for fuzzy matching with unaccent
           if trgm_available? && text_column?(model, field)
             scope.where(
@@ -227,7 +206,10 @@ module Noiseless
 
         def apply_multi_match(scope, node, model)
           query = node.query.to_s
-          fields = node.fields.map(&:to_s)
+          # Drop mapping-only fields; if none of the requested fields are real
+          # columns the query cannot be satisfied — fail closed.
+          fields = node.fields.map(&:to_s).select { |field| column?(model, field) }
+          return scope.none if fields.empty?
 
           conditions = fields.map do |field|
             if trgm_available? && text_column?(model, field)
@@ -272,7 +254,7 @@ module Noiseless
           scope.where("#{quoted_column(node.field.to_s)} ILIKE ?", "#{sanitize_like(node.value)}%")
         end
 
-        def apply_filter_clauses(scope, filter_nodes)
+        def apply_filter_clauses(scope, filter_nodes, model = nil)
           return scope if filter_nodes.empty?
 
           filter_nodes.each do |node|
@@ -280,6 +262,10 @@ module Noiseless
 
             scope = if value.is_a?(Hash) && value[:geo_distance]
                       apply_geo_filter(scope, node)
+                    elsif model && !column?(model, node.field.to_s)
+                      # A filter on a mapping-only field cannot be enforced;
+                      # silently dropping it would broaden results, so fail closed.
+                      scope.none
                     else
                       scope.where(node.field => value)
                     end
@@ -310,13 +296,19 @@ module Noiseless
           scope
         end
 
-        def apply_sorting(scope, sort_nodes)
+        def apply_sorting(scope, sort_nodes, model = nil)
           return scope if sort_nodes.empty?
 
-          order_clauses = sort_nodes.map do |node|
+          order_clauses = sort_nodes.filter_map do |node|
+            field = node.field.to_s
+            # Sorting on a mapping-only field is cosmetic — drop it instead of
+            # erroring the whole query.
+            next if model && !column?(model, field)
+
             direction = node.direction.to_s.upcase == "DESC" ? "DESC" : "ASC"
-            "#{quoted_column(node.field.to_s)} #{direction}"
+            "#{quoted_column(field)} #{direction}"
           end
+          return scope if order_clauses.empty?
 
           scope.order(Arel.sql(order_clauses.join(", ")))
         end
@@ -332,9 +324,7 @@ module Noiseless
 
         # Response formatting
 
-        def format_as_search_response(records, model)
-          total = records.size
-
+        def format_as_search_response(records, model, total: records.size)
           hits = records.map do |record|
             {
               "_index" => model.table_name,
@@ -386,12 +376,15 @@ module Noiseless
         # Helper methods
 
         def resolve_model(indexes, model_class = nil)
-          return model_class if model_class
+          # The standard Model#execute path passes the Noiseless::Model search
+          # class here; only an ActiveRecord model can back a PG search, so
+          # fall through to index-name resolution for anything else.
+          return model_class if active_record_model?(model_class)
 
           index_name = indexes&.first
           return nil unless index_name
 
-          # Try cached model first
+          # Try cached model first (populated via register_model)
           return @model_class_cache[index_name] if @model_class_cache&.key?(index_name)
 
           # Try to infer model from index name
@@ -401,6 +394,10 @@ module Noiseless
           nil
         end
 
+        def active_record_model?(klass)
+          klass.is_a?(Class) && klass < ActiveRecord::Base
+        end
+
         def trgm_available?
           @trgm_available ||= available_extensions.include?("pg_trgm")
         end
@@ -409,9 +406,13 @@ module Noiseless
           @unaccent_available ||= available_extensions.include?("unaccent")
         end
 
+        def column?(model, field)
+          model.columns_hash.key?(field.to_s)
+        end
+
         def text_column?(model, field)
           column = model.columns_hash[field.to_s]
-          column && %i[string text].include?(column.type)
+          column && %i[string text citext].include?(column.type) && !column.array
         end
 
         def quoted_column(field)
@@ -439,18 +440,9 @@ module Noiseless
 
         def process_bulk_action(action)
           if action[:index]
-            index = action[:index][:_index]
-            id = action[:index][:_id]
-            data = action[:index][:data]
-
-            result = execute_index_document(index, id, data)
-            { "index" => result }
+            { "index" => execute_index_document(action[:index][:_index], action[:index][:_id], nil) }
           elsif action[:delete]
-            index = action[:delete][:_index]
-            id = action[:delete][:_id]
-
-            result = execute_delete_document(index, id)
-            { "delete" => result }
+            { "delete" => execute_delete_document(action[:delete][:_index], action[:delete][:_id]) }
           else
             { "error" => "Unknown action type" }
           end

data/lib/noiseless/adapters/execution_modules/typesense_execution.rb

@@ -402,7 +402,7 @@ module Noiseless
           headers
         end
 
-        # rubocop:disable Lint/DuplicateBranch
+        # rubocop:disable-next Lint/DuplicateBranch
         def map_type_to_typesense(elasticsearch_type)
           # Map Elasticsearch types to Typesense types
           case elasticsearch_type
@@ -418,7 +418,6 @@ module Noiseless
             "string" # Default to string for unknown types
           end
         end
-        # rubocop:enable Lint/DuplicateBranch
       end
     end
   end

data/lib/noiseless/connection_manager.rb

@@ -7,9 +7,10 @@ module Noiseless
       @configs = {}
     end
 
-    # Register a named client statically from YAML (boot-time only)
-    def register(name, adapter:, hosts:, timeout: nil)
-      @configs[name.to_sym] = { adapter: adapter, hosts: hosts, timeout: timeout }
+    # Register a named client statically from YAML (boot-time only).
+    # request_timeout: :default uses the adapter default, nil disables the deadline.
+    def register(name, adapter:, hosts:, timeout: nil, request_timeout: :default)
+      @configs[name.to_sym] = { adapter: adapter, hosts: hosts, timeout: timeout, request_timeout: request_timeout }
     end
 
     # Retrieve a client; defaults to :primary
@@ -21,6 +22,7 @@ module Noiseless
         config = @configs.fetch(name) { raise "Unknown connection: #{name}" }
         params = { hosts: config[:hosts] }
         params[:timeout] = config[:timeout] unless config[:timeout].nil?
+        params[:request_timeout] = config[:request_timeout] unless config[:request_timeout] == :default
         Adapters.lookup(config[:adapter], **params)
       end
     end

data/lib/noiseless/query_builder.rb

@@ -221,13 +221,13 @@ module Noiseless
     end
 
     def to_ast
-      filter_nodes = @nodes.select { |n| n.is_a?(AST::Filter) }
-      vector_nodes = @nodes.select { |n| n.is_a?(AST::Vector) }
+      filter_nodes = @nodes.grep(AST::Filter)
+      vector_nodes = @nodes.grep(AST::Vector)
       must_nodes = @nodes.reject do |n|
         n.is_a?(AST::Filter) || n.is_a?(AST::Sort) || n.is_a?(AST::Paginate) || n.is_a?(AST::Vector)
       end
       bool_node = AST::Bool.new(must: must_nodes, filter: filter_nodes)
-      sort_nodes     = @nodes.select { |n| n.is_a?(AST::Sort) }
+      sort_nodes     = @nodes.grep(AST::Sort)
       paginate_node  = @nodes.find { |n| n.is_a?(AST::Paginate) }
       AST::Root.new(
         indexes: @indexes,

data/lib/noiseless/response/empty.rb

@@ -13,7 +13,7 @@ module Noiseless
       end
 
       def each
-        return enum_for(__method__) unless block_given?
+        enum_for(__method__) unless block_given?
       end
     end
   end

data/lib/noiseless/response/results.rb

@@ -12,7 +12,9 @@ module Noiseless
       end
 
       def sources
-        @sources ||= hits.map { |hit| hit["_source"] }
+        # Indifferent access so callers can pluck(:id) or read ["id"] regardless
+        # of which adapter produced the hit.
+        @sources ||= hits.map { |hit| (hit["_source"] || {}).with_indifferent_access }
       end
 
       alias records sources

data/lib/noiseless/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Noiseless
-  VERSION = "0.6.0"
+  VERSION = "0.7.1"
 end

data/lib/noiseless.rb

@@ -98,7 +98,9 @@ module Noiseless
     config.connections_config.each do |name, params|
       adapter_name = params[:adapter]
       hosts = params[:hosts] || []
-      connections.register(name, adapter: adapter_name, hosts: hosts, timeout: params[:timeout])
+      register_params = { adapter: adapter_name, hosts: hosts, timeout: params[:timeout] }
+      register_params[:request_timeout] = params[:request_timeout] if params.key?(:request_timeout)
+      connections.register(name, **register_params)
     end
   end
 

data/lib/tasks/release.rake

@@ -11,9 +11,7 @@ namespace :release do
     version_path = File.expand_path("../../lib/noiseless/version", __dir__)
     require version_path
 
-    if spec.version.to_s != Noiseless::VERSION
-      raise "Version mismatch: gemspec=#{spec.version} lib=#{Noiseless::VERSION}"
-    end
+    raise "Version mismatch: gemspec=#{spec.version} lib=#{Noiseless::VERSION}" if spec.version.to_s != Noiseless::VERSION
 
     ruby = Shellwords.escape(RbConfig.ruby)
     sh "#{ruby} -Ilib -e 'require \"noiseless\"; abort(\"version mismatch\") unless Noiseless::VERSION == \"#{Noiseless::VERSION}\"'"

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: noiseless
 version: !ruby/object:Gem::Version
-  version: 0.6.0
+  version: 0.7.1
 platform: ruby
 authors:
 - Abdelkader Boudih
@@ -29,42 +29,42 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '2.20'
+        version: '2.45'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '2.20'
+        version: '2.45'
 - !ruby/object:Gem::Dependency
   name: async-http
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.80'
+        version: '0.103'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.80'
+        version: '0.103'
 - !ruby/object:Gem::Dependency
   name: async-pool
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.8'
+        version: '0.11'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.8'
+        version: '0.11'
 - !ruby/object:Gem::Dependency
   name: railties
   requirement: !ruby/object:Gem::Requirement
@@ -85,14 +85,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '2.7'
+        version: '2.8'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '2.7'
+        version: '2.8'
 - !ruby/object:Gem::Dependency
   name: async-safe
   requirement: !ruby/object:Gem::Requirement
@@ -109,6 +109,20 @@ dependencies:
         version: '0.5'
 - !ruby/object:Gem::Dependency
   name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '6.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '6.0'
+- !ruby/object:Gem::Dependency
+  name: minitest-mock
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"