noiseless 0.7.0 → 0.7.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 1d1df760c71373680498360fa0daef2cfc6a2dd42b08c7edd67f1027174958a5
-  data.tar.gz: bd720e1daa952b0c64c769a1f2927d5dd9083a5c3722c97c71fc644ab47f0670
+  metadata.gz: 1b661712a5930c3da3a455f6e70c2d99cfbc424cf4e007c58abd587ab170854f
+  data.tar.gz: 547b60b50d5efb9b32da878523d96d5a58c5a7a645ab8bed13ebec40269370b7
 SHA512:
-  metadata.gz: 1802b68562f768b1eee9c5533d26f9a5f387cc8d3052f27474809f889ea142bc8d6903ca4c60c56cfae2989c6e5e36def0abcac0f205d8fe6e86f1a4d87bd979
-  data.tar.gz: 8fad323b3284af9d96d9609dac487fa2980310d3470b074d0d135b2fbc09eef80d294f9369ae3836ec9fa6b0b7d515ed6cf1c7724e88ab55729a0e66ac1ae11d
+  metadata.gz: 17a625f20fb2c879f427d429c82ecb4b9c2b338ffec03bd69de83ee9c2b800800c57eaef0bb6f4d2e32876e91497c5b12bdf389a2f1edcb055bc228764b03473
+  data.tar.gz: 4799c4ba712b8d097b30553ac800caa798349d70c0ecbc7ca901b3f54752a9ed48ce2fcb4d3784d76117c0b7598801efc6f9e3685c5c945e34639740970a8d2e

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/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.7.0"
+  VERSION = "0.7.1"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: noiseless
 version: !ruby/object:Gem::Version
-  version: 0.7.0
+  version: 0.7.1
 platform: ruby
 authors:
 - Abdelkader Boudih