noiseless 0.7.0 → 0.7.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 1d1df760c71373680498360fa0daef2cfc6a2dd42b08c7edd67f1027174958a5
-  data.tar.gz: bd720e1daa952b0c64c769a1f2927d5dd9083a5c3722c97c71fc644ab47f0670
+  metadata.gz: 3a2305879802aa874c213e1a5a87707ec7222af979d21834f21f4fd2c994cb48
+  data.tar.gz: 065cf12ecb097ac17ee1e33d99d5df0ccb79ca4ea6713640f82f6bcac2fad51a
 SHA512:
-  metadata.gz: 1802b68562f768b1eee9c5533d26f9a5f387cc8d3052f27474809f889ea142bc8d6903ca4c60c56cfae2989c6e5e36def0abcac0f205d8fe6e86f1a4d87bd979
-  data.tar.gz: 8fad323b3284af9d96d9609dac487fa2980310d3470b074d0d135b2fbc09eef80d294f9369ae3836ec9fa6b0b7d515ed6cf1c7724e88ab55729a0e66ac1ae11d
+  metadata.gz: dc5302df3e73a9a413e1a7382db1334e11dd28ee2564bb5ae9e0f5d6a2d62f7b241584463678ef6f0db6112740c70d5687fdc425903979056c9d61ff10140bc6
+  data.tar.gz: baba1a26426413fef74f6f900d3146aa9c7bcda385030dd3b722e8277c5dc5b8a25bb79adbf6dc9d0c695e4d3b43e4353e4fe99e3bffb7ec5fc5a0d18ff566cf

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)
@@ -194,11 +169,11 @@ module Noiseless
                     when AST::MultiMatch
                       apply_multi_match(scope, node, model)
                     when AST::Wildcard
-                      apply_wildcard(scope, node)
+                      apply_wildcard(scope, node, model)
                     when AST::Range
-                      apply_range(scope, node)
+                      apply_range(scope, node, model)
                     when AST::Prefix
-                      apply_prefix(scope, node)
+                      apply_prefix(scope, node, model)
                     else
                       scope
                     end
@@ -211,11 +186,16 @@ module Noiseless
           field = node.field.to_s
           value = node.value.to_s
 
-          # Use pg_trgm similarity for fuzzy matching with unaccent
+          # 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, accent-insensitive when
+          # the unaccent extension is present.
           if trgm_available? && text_column?(model, field)
             scope.where(
-              "unaccent(#{quoted_column(field)}) % unaccent(?) OR " \
-              "unaccent(#{quoted_column(field)}) ILIKE unaccent(?)",
+              "#{fuzzy_column(field)} % #{fuzzy_param} OR " \
+              "#{fuzzy_column(field)} ILIKE #{fuzzy_param}",
               value,
               "%#{sanitize_like(value)}%"
             )
@@ -227,12 +207,15 @@ 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)
-              "(unaccent(#{quoted_column(field)}) % unaccent(?) OR " \
-                "unaccent(#{quoted_column(field)}) ILIKE unaccent(?))"
+              "(#{fuzzy_column(field)} % #{fuzzy_param} OR " \
+                "#{fuzzy_column(field)} ILIKE #{fuzzy_param})"
             else
               "#{quoted_column(field)} ILIKE ?"
             end
@@ -249,15 +232,19 @@ module Noiseless
           scope.where(conditions.join(" OR "), *params)
         end
 
-        def apply_wildcard(scope, node)
+        def apply_wildcard(scope, node, model = nil)
           field = node.field.to_s
+          return scope.none if model && !column?(model, field)
+
           # Convert OpenSearch wildcards to SQL: * -> %, ? -> _
           pattern = node.value.to_s.tr("*", "%").tr("?", "_")
 
           scope.where("#{quoted_column(field)} ILIKE ?", pattern)
         end
 
-        def apply_range(scope, node)
+        def apply_range(scope, node, model = nil)
+          return scope.none if model && !column?(model, node.field.to_s)
+
           field = quoted_column(node.field.to_s)
 
           scope = scope.where("#{field} >= ?", node.gte) if node.gte
@@ -268,11 +255,13 @@ module Noiseless
           scope
         end
 
-        def apply_prefix(scope, node)
+        def apply_prefix(scope, node, model = nil)
+          return scope.none if model && !column?(model, node.field.to_s)
+
           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 +269,12 @@ 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
+                    elsif model && array_column?(model, node.field.to_s)
+                      apply_array_filter(scope, node.field.to_s, value, model)
                     else
                       scope.where(node.field => value)
                     end
@@ -288,6 +283,13 @@ module Noiseless
           scope
         end
 
+        def apply_array_filter(scope, field, value, model)
+          cast = "#{model.columns_hash[field].sql_type.sub(/\[\]\z/, '')}[]"
+          operator = value.is_a?(Array) ? "&&" : "@>"
+
+          scope.where("#{quoted_column(field)} #{operator} ARRAY[?]::#{cast}", value)
+        end
+
         def apply_geo_filter(scope, node)
           # Requires PostGIS
           geo_config = node.value[:geo_distance]
@@ -310,14 +312,23 @@ module Noiseless
           scope
         end
 
-        def apply_sorting(scope, sort_nodes)
-          return scope if sort_nodes.empty?
+        def apply_sorting(scope, sort_nodes, model = nil)
+          sorted_fields = []
+          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)
 
-          order_clauses = sort_nodes.map do |node|
+            sorted_fields << field
             direction = node.direction.to_s.upcase == "DESC" ? "DESC" : "ASC"
-            "#{quoted_column(node.field.to_s)} #{direction}"
+            "#{quoted_column(field)} #{direction}"
           end
 
+          primary_key = model.respond_to?(:primary_key) ? model.primary_key : nil
+          order_clauses << "#{quoted_column(primary_key)} ASC" if primary_key && !sorted_fields.include?(primary_key.to_s)
+          return scope if order_clauses.empty?
+
           scope.order(Arel.sql(order_clauses.join(", ")))
         end
 
@@ -332,9 +343,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 +395,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 +413,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 +425,25 @@ 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 array_column?(model, field)
+          model.columns_hash[field.to_s]&.array
+        end
+
+        def fuzzy_column(field)
+          unaccent_available? ? "unaccent(#{quoted_column(field)})" : quoted_column(field)
+        end
+
+        def fuzzy_param
+          unaccent_available? ? "unaccent(?)" : "?"
         end
 
         def quoted_column(field)
@@ -439,18 +471,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.2"
 end

metadata

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